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);
    }
}