POJ 3860 Fruit Weights（数学+最长路径 or 最短路径）

Description

Have you ever thought about comparing the weight of fruits? That’s what you should do in this problem! Given a series of fruit weight comparisons, you should anticipate the result of another comparison. In this problem, all fruits of the same kind are identical and have the same weights. Each fruit weight comparison is something like “a X ≤ b Y” in which a and b are positive integers, and X and Y are fruit names. Such a comparison means that the weight of a fruits of type X is less than or equal to the weight of b fruits of type Y.

Input

The input contains multiple test cases. Each test case starts with a line containing n, which is the number of given comparisons. Each of the next n lines gives a comparison in the form of “a X b Y” meaning that “a X ≤ b Y”. The last line of each test case contains the comparison query in the same form of “a X b Y” inquiring the comparison of “a X” and “b Y”. 
A case of n = 0 shows the end of input and should not be processed. All integers in the input (except the last n which is 0) are positive and are not greater than 100. Fruit names are case-sensitive strings of (lowercase and uppercase) letters with length no more than 50.

Output

For each test case, write one line with your result for that test case. Your result can be one of the followings (assume the comparison query was “a X b Y”):  “<=”: meaning you are sure that “a X ≤ b Y”.  “>=”: meaning you are sure that “a X ≥ b Y”.  “==”: meaning you are sure that “a X = b Y” (i.e. you have reached both of the above results).  “UNAVAILABLE”: meaning that you can say nothing for sure in comparing “a X” and “b Y” (i.e. you have reached none of the above results).  “INCONSISTENT”: meaning that there is an inconsistency in the given comparisons (i.e. you are sure that all the given comparisons for that test case cannot hold at the same time).

题目大意：给n条aX ≤ bY的不等式，其中X、Y是未知数的符号，a、b是常数。最后给出aX ? bY，要求判断 ? 是哪个符号。如果相等输出==，大于等于输出>=，小于等于输出<=，不能判断输出UNAVAILABLE，n条不等式不可能同时成立输出INCONSISTENT。

思路：首先X、Y是各种各样的字符串，所以先离散化，C++里面的map<string, int>是不错的选择。然后我们就要考虑，不同的不等式，该怎样才能联立起来。比如2a ≤ 3b，5b ≤ 7c，这样就会确定了一个关于a和c的不等式，然而我们须要表现在代码里面，不是很容易做到。

所以移向，2/3 a ≤ b， 5/7 b ≤ c，如果 c 到 b 连一条边，权值为 5/7； b 到 a 连一条边，权值为 2/3。那么，我们从 c 走到 a，就可以得到 (5/7 * 2/3) * a ≤ c。如果有假设提问是x * a ? y * c，那么对所有x/y ≤ (5/7 * 2/3)，因为若p ≤ q，有pa ≤ qa ≤ qc。

然后对每一条边，取最大的权值。因为若有两条边pa ≤ pc，qa ≤ qc，且p ≤ q，那么我们只要保留qa ≤ qc，那么我们就可以推断出pa ≤ pc。

根据上述推论，我们用floyd来直接求出最长路径，mat[j][i]代表mat[j][i] * i ≤ j。n个不等式冲突，就说明存在mat[i][i] ＞ 1，令mat[i][i] * i ≤ i无法成立，输出INCONSISTENT。对询问x * i ? y * j，若有y/x = mat[i][j]且x/y = mat[j][i]，那么有x * i = y * j。若有y/x ≤ mat[i][j]，则有x * i ≥ y * j。若 x/y ≤ mat[j][i]，则有x * i ≤ y * j。若前面都不成立，则说明无法判断，输出UNAVAILABLE。

对于询问x * i ? y * j， i 或 j 前面都没有出现过的，好像是没有这种情况，别人没管这个也能AC。

PS：之前闲得无聊写了一个分数类结果RE了，大概是乘起来太大然后求约数的时候被零除跪了，好吧这不是重点。

PS2：最短路径的那个代码就是把原来的mat[j][i] * i ≤ j换成了i ≤ j * mat[j][i]，思路差不多。

代码（125MS）（最长路径）：

 #include <cstdio>
 #include <cstring>
 #include <map>
 #include <string>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 typedef long long LL;

 const int MAXN = ;
 const double EPS = 1e-;

 map<string, int> mp;
 string a, b;
 int m, n;

 double x, y;
 int aid, bid;
 double mat[MAXN][MAXN];

 inline int sgn(double x) {
     return (x > EPS) - (x < -EPS);
 }

 bool floyd() {
     for(int k = ; k <= n; ++k)
         for(int i = ; i <= n; ++i) if(mat[i][k] > )
             for(int j = ; j <= n; ++j) if(mat[k][j] > )
                 if(mat[i][k] * mat[k][j] > mat[i][j]) mat[i][j] = mat[i][k] * mat[k][j];
                 /*
     for(int k = 1; k <= n; ++k)
         for(int i = 1; i <= n; ++i) if(mat[i][k] > 0)
             for(int j = 1; j <= n; ++j) if(mat[k][j] > 0)
                 if(mat[i][j] > 0 && sgn(mat[i][k] * mat[k][j] - mat[i][j]) == 1) return false;*/
     for(int i = ; i <= n; ++i)
         for(int j = i + ; j <= n; ++j) {
             if(mat[i][j] <  || mat[j][i] < ) continue;
             if(mat[i][j] * mat[j][i] > ) return false;
         }
     return true;
 }

 int main() {
     ios::sync_with_stdio(false);
     while(cin>>m) {
         if(m == ) break;
         n = ;
         mp.clear();
         for(int i = ; i < MAXN; ++i) {
             for(int j = ; j < MAXN; ++j) mat[i][j] = -;
             mat[i][i] = ;
         }
         for(int i = ; i < m; ++i) {
             cin>>x>>a>>y>>b;
             if(mp.find(a) != mp.end()) aid = mp[a];
             else mp[a] = aid = ++n;
             if(mp.find(b) != mp.end()) bid = mp[b];
             else mp[b] = bid = ++n;
             //if(mat[aid][bid] < double(x, y)) mat[aid][bid] = double(x, y);
             if(mat[bid][aid] < x / y) mat[bid][aid] = x / y;
         }
         cin>>x>>a>>y>>b;
         if(!floyd()) {
             puts("INCONSISTENT");
             continue;
         }
         if(mp.find(a) == mp.end() || mp.find(b) == mp.end()) {
             puts("UNAVAILABLE");
             continue;
         }
         aid = mp[a];
         bid = mp[b];
         if(sgn(mat[aid][bid] - y / x) ==   && sgn(mat[bid][aid] - x / y) == ) {
             puts("==");
             continue;
         }
         if(mat[bid][aid] >  && sgn(mat[bid][aid] - x / y) >= ) {
             puts("<=");
             continue;
         }
         if(mat[aid][bid] >  && sgn(mat[aid][bid] - y / x) >= ) {
             puts(">=");
             continue;
         }
         puts("UNAVAILABLE");
     }
 }

代码（125MS）（最短路径）：

 #include <cstdio>
 #include <cstring>
 #include <map>
 #include <string>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 typedef long long LL;

 const int MAXN = ;
 const double EPS = 1e-;

 map<string, int> mp;
 string a, b;
 int m, n;

 double x, y;
 int aid, bid;
 double mat[MAXN][MAXN];

 inline int sgn(double x) {
     return (x > EPS) - (x < -EPS);
 }

 bool floyd() {
     for(int k = ; k <= n; ++k)
         for(int i = ; i <= n; ++i) if(mat[i][k] > )
             for(int j = ; j <= n; ++j) if(mat[k][j] > )
                 if(mat[i][j] <  || mat[i][k] * mat[k][j] < mat[i][j]) mat[i][j] = mat[i][k] * mat[k][j];
     for(int i = ; i <= n; ++i)
         for(int j = i + ; j <= n; ++j) {
             if(mat[i][j] <  || mat[j][i] < ) continue;
             if(sgn(mat[i][j] * mat[j][i] - ) < ) return false;
         }
     return true;
 }

 int main() {
     ios::sync_with_stdio(false);
     while(cin>>m) {
         if(m == ) break;
         n = ;
         mp.clear();
         for(int i = ; i < MAXN; ++i) {
             for(int j = ; j < MAXN; ++j) mat[i][j] = -;
             mat[i][i] = ;
         }
         for(int i = ; i < m; ++i) {
             cin>>x>>a>>y>>b;
             if(mp.find(a) != mp.end()) aid = mp[a];
             else mp[a] = aid = ++n;
             if(mp.find(b) != mp.end()) bid = mp[b];
             else mp[b] = bid = ++n;
             if(aid == bid) continue;
             //if(mat[aid][bid] < double(x, y)) mat[aid][bid] = double(x, y);
             if(mat[bid][aid] <  || mat[bid][aid] > y / x) mat[bid][aid] = y / x;
         }
         cin>>x>>a>>y>>b;
         if(!floyd()) {
             puts("INCONSISTENT");
             continue;
         }
         if(mp.find(a) == mp.end() || mp.find(b) == mp.end()) {
             puts("UNAVAILABLE");
             continue;
         }
         aid = mp[a];
         bid = mp[b];
         if(sgn(mat[aid][bid] - x / y) ==   && sgn(mat[bid][aid] - y / x) == ) {
             puts("==");
             continue;
         }
         if(mat[bid][aid] >  && sgn(mat[bid][aid] - y / x) <= ) {
             puts("<=");
             continue;
         }
         if(mat[aid][bid] >  && sgn(mat[aid][bid] - x / y) <= ) {
             puts(">=");
             continue;
         }
         puts("UNAVAILABLE");
     }
 }