hdu3666 THE MATRIX PROBLEM

这道题题号真吉利啊

这道题是判断是否存在两个数组a,b是的对给定的矩阵c满足

L <= c[i][j] * a[i] / b[j] <= U 把乘除号 看作加减号 （或者直接两边取log）

那么就是两个不等式 转换成差分约束系统

判断是否存在负圈就好

spfa下来会超时 ，有两种方法可以解决

一是将入队次数改为根号n即可 （不要问为什么，我也不知道哪里看到过） 不推荐

二是用dfs判断 速度也很快

//#pragma warning (disable: 4786)
//#pragma comment (linker, "/STACK:16777216")
//HEAD
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
//LOOP
#define FF(i, a, b) for(int i = (a); i < (b); ++i)
#define FD(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define FE(i, a, b) for(int i = (a); i <= (b); ++i)
#define FED(i, b, a) for(int i = (b); i>= (a); --i)
#define REP(i, N) for(int i = 0; i < (N); ++i)
#define CLR(A,value) memset(A,value,sizeof(A))
#define CPY(a, b) memcpy(a, b, sizeof(a))
#define FC(it, c) for(__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
//STL
#define SZ(V) (int)V.size()
#define PB push_back
#define EQ(a, b) (fabs((a) - (b)) <= 1e-10)
#define ALL(c) (c).begin(), (c).end()
//INPUT
#define RI(n) scanf("%d", &n)
#define RII(n, m) scanf("%d%d", &n, &m)
#define RIII(n, m, k) scanf("%d%d%d", &n, &m, &k)
#define RIV(n, m, k, p) scanf("%d%d%d%d", &n, &m, &k, &p)
#define RV(n, m, k, p, q) scanf("%d%d%d%d%d", &n, &m, &k, &p, &q)
#define RS(s) scanf("%s", s)
//OUTPUT
#define WI(n) printf("%d\n", n)
#define WS(s) printf("%s\n", s)
typedef long long LL;
typedef unsigned long long ULL;
typedef vector <int> VI;
const int INF = 0x3f3f3f3f;
const double eps = 1e-10;
const int maxn = 850;
typedef pair<int, int> pii;

struct Edge{
int from, to;
double dist;
Edge(int a, int b, double c) : from(a), to(b), dist(c){}
};
int mat[450][450];

struct BellmanFord{
int n, m;
vector<Edge> edges;
VI G[maxn];
bool inq[maxn];
double d[maxn];
int cnt[maxn];

void init(int n)
{
this-> n = n;
REP(i, n + 1)
G[i].clear();
edges.clear();
}

void add(int from, int to, double dist)
{
Edge e1 = Edge(from, to, dist);
edges.PB(e1);
m = edges.size();
G[from].PB(m - 1);
}

bool dfs(int u)
{
inq[u] = 1;
REP(i, SZ(G[u]))
{
Edge &e = edges[G[u][i]];
if (d[e.to] > d[u] * e.dist)
{
d[e.to] = d[u] * e.dist;
if (inq[e.to] || dfs(e.to)) return 1;
}
}
inq[u] = 0;
return 0;
}

bool spfa(int s)
{
queue<int> Q;
CLR(inq, false), CLR(cnt, 0);
REP(i, n)
d[i] = INF;

d[s] = 1.0, inq[s] = 1;
Q.push(s);

REP(i, n)
if (dfs(i))
return 1;
return 0;

//    while (!Q.empty())///spfa判负圈，超时
//    {
//        int u = Q.front(); Q.pop();
//        inq[u] = 0;
//        REP(i, SZ(G[u]))
//        {
//            Edge &e = edges[G[u][i]];
//            if (d[e.to] > d[u] * e.dist)
//            {
//                d[e.to] = d[u] * e.dist;
//                if (!inq[e.to])
//                {
//                    Q.push(e.to);
//                    inq[e.to] = 1;
//                    if (++cnt[e.to] > n)    return 1;///将这里的n改为sqrt(n)
//                }
//            }
//        }
//    }

//    return 0;
}
}neg;

void solve(int n, int m, int L, int U)
{
neg.init(n + m + 1);
REP(i, n + m)
neg.add(n + m, i, 1.0);
REP(i, n)
REP(j, m)
{
neg.add(j + n, i, U * 1.0 / mat[i][j]);
neg.add(i, j + n, 1.0 * mat[i][j] / L);
}
if (neg.spfa(n + m))
puts("NO");
else
puts("YES");
}

int main()
{
int n, m, L, U;
while (~RIV(n, m, L, U))
{
REP(i, n)
REP(j, m)
scanf("%d", &mat[i][j]);
solve(n, m, L, U);
}
}