HDU 4818 RP problem 高斯消元

题意：一个有向图 图中所有结点的权值和为1 每个结点都会把自己的权值均分给自己相邻的结点 如果经过一轮分配后 各个结点的权值不变 则称这个图是稳定的 给你一个这样的图 问你如何分配各个点的权值 使得这个图是稳定的 输出分配方案的种类数 如果方案唯一 又问你是否可以添加一条从n-1到其它某个点的有向边 使得n-1这个点的权值最大化 并输出所连接的那个点

思路：不难想到这道题是高斯消元 公式也比较好列 a[i][i]=-1 n个方程n个未知数 其中有一个方程式没用的 因为这n个方程是解不出答案的 还有一个方程就是所有点的权值和为一 这样列出方程后如果无解 就说明有无穷多个解 否则只有一解 如果暴力枚举添加的边然后跑n次高斯消元 复杂度为O(n^4) 会超时 加一步优化即可解决 观察发现所做的n次高斯消元的前n-1列都是相同的 也就是说做了很多无用功 而高斯消元只做min(row, col)次消元 row是方程个数 col是未知数个数 每次只消一列 也即是说最终只会消除前row-1列 因此后面的每一列并不会彼此影响 故只需将这n个方程组的最后一列加到一个方程组里 在一个矩阵中即可跑出所有n次的结果即可

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
#include <cstdlib>
using namespace std;

const int maxn = 200 +10;
const double eps = 1e-8;

int n, m;
int g[maxn][maxn], in[maxn];
int save[maxn];
double a[maxn][maxn];
double x[maxn];
vector<int> re_G[maxn];

int equ, var;

int Gauss()
{
          int i,j,k,col,max_r;
          for(k=0,col=0; k<equ&&col<var; k++,col++)
          {
                    max_r = k;
                    for(i=k+1; i<equ; i++)
                              if(fabs(a[i][col])>fabs(a[max_r][col]))
                                        max_r = i;
                    if(fabs(a[max_r][col])<eps)return 0;
                    if(k != max_r)
                    {
                              for(j=col; j<var; j++)
                                        swap(a[k][j],a[max_r][j]);
                              swap(x[k],x[max_r]);
                    }
                    x[k]/=a[k][col];
                    for(j=col+1; j<var; j++)a[k][j]/=a[k][col];
                    a[k][col] = 1;
                    for(i=0; i<equ; i++)
                              if(i!=k)
                              {
                                        x[i] -= x[k]*a[i][k];
                                        for(j=col+1; j<var; j++)a[i][j]-=a[k][j]*a[i][col];
                                        a[i][col]=0;
                              }
          }
          return 1;
}

void solve(){
         scanf("%d%d",&n, &m);
         memset(in, 0, sizeof(in));
         memset(g, 0, sizeof(g));
         memset(a, 0, sizeof(a));
         memset(x, 0, sizeof(x));
         for(int i = 0; i < n; i++) re_G[i].clear();
         for(int i = 0; i < m; i++){
                    int u, v;
                    scanf("%d%d", &u, &v);
                    if(u != v) g[u][v] = 1;
         }
         for(int i = 0; i < n; i++)
         for(int j = 0; j < n; j++){
                    if(i != j && g[i][j]){
                              in[i]++;
                              re_G[j].push_back(i);
                    }
         }
         for(int i = 0; i < n; i++){
         for(int j = 0; j < (int)re_G[i].size(); j++){
                    int v = re_G[i][j];
                    if(v != i) a[i][v] = 1.0 / in[v];
         }
          a[i][i] = -1;
         }
         for(int i = 0; i < n; i++) a[n-1][i] = 1; x[n-1] = 1;
         var = equ = n;
         for(int i = 0; i < n-1; i++){
                    if(g[n-1][i] == 0){ //枚举每一个与n-1不相连的边
                              for(int j = 0; j < n-1; j++){
                                        if(g[n-1][j]){
                                                  a[j][var] = 1.0 / (in[n-1] + 1);
                                        }
                              }
                              a[i][var] = 1.0 / (in[n-1] + 1);
                              a[n-1][var] = 1;
                              save[var] = i;
                              var++;
                    }
         }
         if(!Gauss()) printf("INF\n");
         else{
                    int ans = -1;
                    double cnt_max = x[n-1];
                    for(int i = n; i < var; i++){
                              if(x[n-1] / a[n-1][i] > cnt_max){//这个地方除以a[n-1][i]的原因是消除第i个未知数前面的系数
                                        ans = save[i];
                                        cnt_max = x[n-1] / a[n-1][i];
                              }
                    }
                    printf("1 %d\n", ans);
         }
}

int main()
{
          int T;
          scanf("%d", &T);
          while(T--) solve();
          return 0;
}
/*
1
4 4
0 3
2 3
0 1
1 2
*/