数算实习 ACM Computer Factory 网络流的Dinic算法

ACM Computer Factory

电脑公司生产电脑有N个机器，每个机器单位时间产量为Qi。

电脑由P个部件组成，每个机器工作时只能把有某些部件的半成品电脑(或什么都没有的空电脑）变成有另一些部件的半成品电脑或完整电脑(也可能移除某些部件）。
1表示有部件，0表示无部件，2表示有无部件皆可

求电脑公司的单位时间最大产量，以及哪些机器有协作关系，即一台机器把它的产品交给哪些机器加工。

样例输入
Sample input 1
3 4
15 0 0 0 0 1 0
10 0 0 0 0 1 1
30 0 1 2 1 1 1
3 0 2 1 1 1 1
Sample input 2
3 5
5 0 0 0 0 1 0
100 0 1 0 1 0 1
3 0 1 0 1 1 0
1 1 0 1 1 1 0
300 1 1 2 1 1 1
Sample input 3
2 2
100 0 0 1 0
200 0 1 1 1

样例输出Sample output 1
25 2
1 3 15
2 3 10
Sample output 2
4 5
1 3 3
3 5 3
1 2 1
2 4 1
4 5 1
Sample output 3
0 0

 #include <iostream>
 #include <algorithm>
 #include <string>
 #include <cstring>
 #include <deque> 
 using namespace std;
 
 const int INT = 9999;
 struct point                          //记录结点i状态
 {
  int a[15];
 };
 int len[120][120] = { 0 };            //记录流量
 int visited[120] = { 0 };             //记录结点是否被访问
 point state[120];
 int layer[120] = { 0 };
 
 bool judgethesame(point p1, point p2, int p)
 {
  for (int i = 1; i <= p; i++)
  {
   if (p1.a[i] == p2.a[i] || p1.a[i] == 2)
    continue;
   else
    return 0;
  }
  return 1;
 }
 
 bool countlayer(int n)
 {
  int lay = 0;
  deque<int> q;
  memset(layer, -1, sizeof(layer));
  layer[0] = 0;
  q.push_back(0);
  while (!q.empty())
  {
   int v = q.front();
   q.pop_front();
   for (int i = 1; i <= 2 * n + 1; i++)
   {
    if (len[v][i] > 0 && layer[i] == -1)
    {
     layer[i] = layer[v] + 1;
     if (i == 2 * n + 1)
      return true;
     q.push_back(i);
    }
   }
  }
  return false;
 }
 
 int Dinic(int n)
 {
  int i, s;
  int nmaxflow = 0;
  deque<int> q;
  while (countlayer(n))
  {
   q.push_back(0);
   memset(visited, 0, sizeof(visited));
   visited[0] = 1;
   while (!q.empty())
   {
    int nd = q.back();
    if (nd == 2 * n + 1)
    {
     int nminc = INT;
     int nminc_vs;
     for (int i = 1; i < q.size(); i++)
     {
      int vs = q[i - 1];
      int ve = q[i];
      if (len[vs][ve] > 0)
      {
       if (len[vs][ve] < nminc)
       {
        nminc = len[vs][ve];
        nminc_vs = vs;
       }
      }
     }
     nmaxflow += nminc;
     for (int i = 1; i < q.size(); i++)
     {
      int vs = q[i - 1];
      int ve = q[i];
      len[vs][ve] -= nminc;
      len[ve][vs] += nminc;
     }
     while (!q.empty() && q.back() != nminc_vs) 
     { 
      visited[q.back()] = 0; 
      q.pop_back(); 
     }
    }
    else
    {
     for (i = 1; i <= 2 * n + 1; i++)
     {
      if (len[nd][i] > 0 && layer[i] == layer[nd] + 1 && !visited[i])
      {
       visited[i] = 1;
       q.push_back(i);
       break;
      }
     }
     if (i > 2 * n + 1)
      q.pop_back();
    }
   }
  }
  return nmaxflow;
 }
 
 int main()
 {
  int p, n;
  cin >> p >> n;
  for (int i = 1; i <= n; i++)                   //注意一共2n+2个点，包括一个起点和一个终点
  {
   int val;
   cin >> val;
   int flag = 0;
   int num;
   for (int k = 1; k <= p; k++)
   {
    cin >> num;
    state[i].a[k] = num;
    if (state[i].a[k] == 1)
     flag = 1;
   }
   if (flag == 0)
    len[0][i] = INT;                        //从起点到000(2)为无穷流量
   flag = 0;
   for (int k = 1; k <= p; k++)
   {
    cin >> num;
    state[i + n].a[k] = num;
    if (state[i + n].a[k] == 0)
     flag = 1;
   }
   if (flag == 0)
    len[i + n][2 * n + 1] = INT;            //从111(2)到终点为无穷流量
   len[i][i + n] = val;
  }
  for (int i = 1; i <= n; i++)
  {
   for (int j = 1; j <= n; j++)
   {
    if (i != j)
    {
     if (judgethesame(state[i], state[j + n], p))           //判断是否有一个机器的成品可以作为另一个机器的原料
     {
      len[j + n][i] = INT;
     }
    }
   }
  }
  int m = Dinic(n);
  cout << m;
  if (m == 0)
   cout << " 0" << endl;
  else
  {
   int sum = 0;
   int b[120];
   int e[120];
   int num[120];
   for (int i = 1; i <= n; i++)
    for (int j = 1; j <= n; j++)
    {
     if (i != j && len[j + n][i] > 0 && len[j + n][i] != INT)
     {
      b[sum] = j;
      e[sum] = i;
      num[sum] = INT - len[j + n][i];
      sum++;
     }
    }
   cout << " " << sum << endl;
   for (int i = 0; i < sum; i++)
   {
    cout << b[i] << " " << e[i] << " " << num[i] << endl;
   }
  }

  return 0;
 }