uvalive 3276 The Great Wall Game

题意：

一个n * n的棋盘上放着n个棋子，现在要求把这n个棋子用最少的步数移到同一条直线上，即同一列同一行或者同一对角线（两条）。输出最少的步数（只能往四个方向移动，即正东，正西，正南，正北）。

思路：

每个棋子唯一对应一个格子，每个棋子不能在同一个格子，那么就相当于一个二分图（强行二分图）。

因为n很小，所以可以枚举每一行，每一列，两条对角线，然后每个点移动到每一条直线的每一个格子都有一个距离，那么这个点就向格子连一条权值为距离的边，这个问题就转化成了求所有最佳完美的匹配中的最小值，用KM算法。

因为我们求的是最小步数，所以求的是带权二分图的最小匹配。

求最小匹配，就将每一条边的权值取反，然后求最大匹配，再将最后的结果取反就得到了最小匹配的结果。

复杂度为O(n^4)。

注意：输出很坑，每一个答案后都有一个换行，并不是两个中间输出一个，也就是说，最后一个后面也有换行。

代码：

 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <vector>
 using namespace std;

 const int N = ;
 const int inf = 0x3f3f3f3f;

 int love[N][N];
 int lx[N],ly[N];
 bool visx[N],visy[N];
 int match[N];
 int slack[N];

 struct node
 {
     int x,y;

     node(int aa,int bb)
     {
         x = aa;
         y = bb;
     }
 };

 vector<node> vn;

 int mabs(int x)
 {
     return x >=  ? x : -x;
 }

 bool dfs(int u,int n)
 {
     visx[u] = ;

     for (int i = ;i <= n;i++)
     {
         if (visy[i]) continue;

         int gap = lx[u] + ly[i] - love[u][i];

         if (gap == )
         {
             visy[i] = ;

             if (match[i] == - || dfs(match[i],n))
             {
                 match[i] = u;
                 return true;
             }
         }
         else
         {
             slack[i] = min(gap,slack[i]);
         }
     }

     return false;
 }

 int km(int n)
 {
     memset(match,-,sizeof(match));
     memset(ly,,sizeof(ly));

     for (int i = ;i <= n;i++)
     {
         lx[i] = love[i][];

         for (int j = ;j <= n;j++)
         {
             lx[i] = max(lx[i],love[i][j]);
         }
     }

     for (int i = ;i <= n;i++)
     {
         memset(slack,inf,sizeof(slack));

         while ()
         {
             memset(visx,,sizeof(visx));
             memset(visy,,sizeof(visy));

             if (dfs(i,n)) break;

             int d = inf;

             for (int j = ;j <= n;j++)
             {
                 if (!visy[j]) d = min(d,slack[j]);
             }

             for (int j = ;j <= n;j++)
             {
                 if (visx[j]) lx[j] -= d;

                 if (visy[j]) ly[j] += d;
             }
         }

     }

     int res = ;

     for (int i = ;i <= n;i++)
     {
         res += love[match[i]][i];
     }

     return res;
 }

 int main()
 {
     int n;
     int kase = ;

     while (scanf("%d",&n) != EOF && n)
     {
         vn.clear();

         for (int i = ;i < n;i++)
         {
             int a,b;

             scanf("%d%d",&a,&b);

             vn.push_back(node(a,b));
         }

         //if (kase) printf("\n");

         int ans = 1e8;

         for (int i = ;i <= n;i++)
         {
             for (int j = ;j < vn.size();j++)
             {
                 for (int k = ;k <= n;k++)
                 {
                     int dx = mabs(vn[j].x - i);
                     int dy = mabs(vn[j].y - k);
                     love[j+][k] = -(dx + dy);
                 }
             }

             int tmp = -km(n);

             //printf("%d **\n",tmp);

             ans = min(tmp,ans);
         }

         for (int i = ;i <= n;i++)
         {
             for (int j = ;j < vn.size();j++)
             {
                 for (int k = ;k <= n;k++)
                 {
                     int dy = mabs(vn[j].y - i);
                     int dx = mabs(vn[j].x - k);
                     love[j+][k] = -(dx + dy);
                 }
             }

             int tmp = -km(n);

             ans = min(tmp,ans);

             //printf("%d **\n",tmp);
         }

         for (int i = ;i <= n;i++)
         {
             for (int j = ;j < vn.size();j++)
             {
                 int dx = mabs(vn[j].x - i);
                 int dy = mabs(vn[j].y - i);

                 love[j+][i] = -(dx + dy);
             }
         }

         ans = min(ans,-km(n));

         for (int i = ;i <= n;i++)
         {
             for (int j = ;j < vn.size();j++)
             {
                 int dx = mabs(vn[j].x - i);
                 int dy = mabs(vn[j].y - (n - i + ));

                 love[j+][i] = -(dx + dy);
             }
         }

         ans = min(ans,-km(n));

         printf("Board %d: %d moves required.\n\n",++kase,ans);
     }

     return ;
 }