[hdu 4307]Matrix

真是一道很好的题目喵~

一看题面真是无语了……很直接、很暴力、很恶心。说实话，除了 straight forward 我脑子里就没想过别的

上网看了一下居然是最小割，脑子里面一下子就清醒了，N<=1000 而且 A[i]=0 or 1 的，似乎数据上具备了网络流的前提~

现在来看一看那个公式：

稍微变一变：

这样就非常明显了，要最大化 D 的值，就要最小化后面括号里的表达式

而表达式的值仅和 a_i 的值有关，可以视为：

若取 a_i=0 时，要付出 ∑b_ij 的代价，若取 a_i=1，则要付出 c_i 的代价，同时，若  a_i=1 且  a_j=0 ，则又要付出 b_ij 的代价，问最小代价

这尼玛经典的最小割，建立源点 S 汇点 T ，令 a_i 向 S 和 T 连边，若 a_i 最终与 S 相连则 a_i=1，否则 a_i=0，再在 a_i 和 a_j 间连一条边，表示若 a_i 和 a_j 最后分属不同集合，则需付出 b_ij 的代价

然后，这道题就被 AC 了……

 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #define min(x, y) ((x)<(y) ? (x):(y))
 const int inf=0x7FFFFFFF;
 const int sizeOfPoint=;
 const int sizeOfEdge=;

 int cases;
 int N;
 int S, T;
 int B[sizeOfPoint][sizeOfPoint], Bi[sizeOfPoint], C[sizeOfPoint];
 int h[sizeOfPoint];
 inline int getint();
 inline void putint(int);

 struct edge {int point, flow; edge * next, * pair;};
 edge memory[sizeOfEdge], * port=memory;
 edge * e[sizeOfPoint];
 inline void clear() {port=memory; memset(e, , sizeof e);}
 inline edge * newedge(int point, int flow, edge * next)
 {
     edge *  ret=port++;
     ret->point=point; ret->flow=flow; ret->next=next;
     return ret;
 }
 inline void link(int u, int v, int f)
 {
     e[u]=newedge(v, f, e[u]); e[v]=newedge(u, , e[v]);
     e[u]->pair=e[v]; e[v]->pair=e[u];
 }
 inline bool bfs();
 inline int aug();
 inline int dinic();

 int main()
 {
     int ans;

     for (cases=getint();cases;cases--)
     {
         clear();
         N=getint();
         memset(Bi, , sizeof Bi);
         for (int i=;i<=N;i++)
             for (int j=;j<=N;j++)
                 Bi[i]+=(B[i][j]=getint());
         for (int i=;i<=N;i++)
             C[i]=getint();
         ans=;
         for (int i=;i<=N;i++) ans+=Bi[i];

         S=; T=N+;
         for (int i=;i<=N;i++)
             link(S, i, Bi[i]),
             link(i, T, C[i]);
         for (int i=;i<=N;i++)
             for (int j=;j<=N;j++) if (i!=j)
                 link(i, j, B[i][j]);
         ans-=dinic();
         putint(ans);
     }

     return ;
 }
 inline int getint()
 {
     register int num=;
     register char ch;
     do ch=getchar(); while (ch<'' || ch>'');
     do num=num*+ch-'', ch=getchar(); while (ch>='' && ch<='');
     return num;
 }
 inline void putint(int num)
 {
     char stack[];
     register int top=;
     if (num==) stack[top=]='';
     for ( ;num;num/=) stack[++top]=num%+'';
     for ( ;top;top--) putchar(stack[top]);
     putchar('\n');
 }
 inline bool bfs()
 {
     static int q[sizeOfPoint];
     int l=, r=;
     memset(h, 0xFF, sizeof h); h[T]=;
     for (q[r++]=T;l<r;l++)
     {
         int u=q[l];
         for (edge * i=e[u];i;i=i->next) if (i->pair->flow && h[i->point]==-)
             h[q[r++]=i->point]=h[u]+;
     }
     return h[S]>=;
 }
 inline int aug()
 {
     static edge * t[sizeOfPoint], * path[sizeOfPoint];
     static int aug[sizeOfPoint];
     int flow=;
     memset(aug, , sizeof aug); aug[S]=inf;
     memset(path, , sizeof path);
     memmove(t, e, sizeof e);
     for (int u=S; ; )
     {
         if (u==T)
         {
             flow+=aug[T];
             for (edge * i=path[T];i;i=path[i->point])
                 i->pair->flow-=aug[T], i->flow+=aug[T], aug[i->point]-=aug[T];
             for (edge * i=path[T];i && u==T;i=path[i->point]) if (aug[i->point])
                 u=i->point;
         }
         edge *& i=t[u];
         for ( ;i && (!i->flow || h[i->point]+!=h[u]);i=i->next);
         if (i)
         {
             path[i->point]=i->pair; aug[i->point]=min(aug[u], i->flow);
             u=i->point;
         }
         else
         {
             if (u==S) break;
             h[u]=-;
             u=path[u]->point;
         }
     }
     return flow;
 }
 inline int dinic()
 {
     register int flow=;
     for ( ;bfs();flow+=aug());
     return flow;
 }

本傻装B系列

这道题告诉我们，如果要求的是一个最大/小化某个表达式的数组，且每个数字的取值范围都很小时可以考虑用最小割做~