HDU 3666 THE MATRIX PROBLEM （差分约束，最短路）

题意：

　　给一个n*m矩阵，每个格子上有一个数字a[i][j]，给定L和U，问：是否有这样两个序列{a1...an}和{b1...bn}，满足 L<=a[i][j]*ai/bj<=U 。若存在输出yes，否则no。

思路：

　　能够得到的是一堆不等式，那么可以用最短路来解决差分约束系统。但是a[i][j]*ai/bj<=U是除的，得提前变成减的才行。可以用对数log来解决，先不管a[i][j]，logai-logbj<=U不就行了？可以得到：

　　（1）logai - logbj<=U/a[i][j]       （注：这里已经是浮点型了）

　　（2）logbj - logai<=-L/a[i][j]

根据这个来建图即可，值得注意的是，点是log(x)，而不是x，只有n+m个点。

但是起点呢？不妨以随便以一个点r作为起点，置cost[r]=0，其他INF，来进行最短路，我们只需要对其判断是否有负环即可。

 //#include <bits/stdc++.h>
 #include <cstdio>
 #include <cstring>
 #include <map>
 #include <iostream>
 #include <deque>
 #include <vector>
 #define INF 0x7f7f7f7f
 #define pii pair<int,int>
 #define LL unsigned long long
 using namespace std;
 const int N=;
 struct node
 {
     int from,to;
     double cost;
     node(){};
     node(int from,int to,double cost):from(from),to(to),cost(cost){};
 }edge[N*N];
 vector<int> vect[N];
 int edge_cnt;

 void add_node(int from,int to,double cost)
 {
     edge[edge_cnt]=node(from,to,cost);
     vect[from].push_back(edge_cnt++);
 }

 double cost[N];
 int cnt[N];
 bool inq[N];
 int spfa(int up)
 {
     memset(inq,  , sizeof(inq));
     memset(cost, 0x7f, sizeof(cost));
     cost[]=;
     deque<int> que(,);//随便以1作为起点

     while(!que.empty())
     {
         int x=que.front();que.pop_front();
         inq[x]=;
         for(int i=; i<vect[x].size(); i++)
         {
             node e=edge[vect[x][i]];
             if(cost[e.to]>cost[x]+e.cost)
             {
                 cost[e.to]=cost[x]+e.cost;
                 if(!inq[e.to])
                 {
                     inq[e.to]=;
                     if(++cnt[e.to]>up)  return false;
                     if(!que.empty()&&cost[e.to]<cost[que.front()])
                         que.push_front(e.to);//一个优化
                     else
                         que.push_back(e.to);
                 }
             }
         }
     }
     return true;
 }

 int main()
 {
     freopen("input.txt", "r", stdin);
     int n, m, a, b, c, L, U;
     double g;

     while(~scanf("%d %d %d %d", &n, &m, &L, &U))
     {
         edge_cnt=;
         memset(edge,,sizeof(edge));
         for(int i=; i<=n+m; i++)  vect[i].clear();

         //a1~an编号为1~n，b1~bn编号为n+1~n+m
         for(int i=; i<=n; i++)
         {
             for(int j=; j<=m; j++)
             {
                 scanf("%lf",&g);
                 add_node(i, n+j, -L/g);
                 add_node(n+j, i, U/g);
             }
         }
         if( spfa(n+m) )    puts("YES");
         else    puts("NO");
     }
     return ;
 }

AC代码