uva 104 Arbitrage

原题中文翻译：（来自lucky 猫）
Arbitrage

所謂的「三角套匯（arbitrage）」就是在幾種外幣中做金錢的交易，期待從匯差中獲取少許的利潤。例如：1 元美金可以買 0.7 英鎊，1 元英鎊可以買 9.5 法朗，1 元法朗可以買 0.16 美金。所以如果我們把 1 元美金換成英鎊，再把英鎊換成法朗，最後再把法朗換回美金，那麼最後得到的美金將是：1*0.7*9.5*0.16=1.064 美元。也就是說我們可以從中獲取匯差 0.064 美元，相當於賺了 6.4% 。

請你寫一個程式找出是否有這樣套匯的情況，可以獲取如上所述的利益。

要產生一個成功的套匯，在換外幣的過程中，開始的幣種一定得等於最後的幣種。但是從哪一種開始都可以。

Input

輸入含有多組測試資料。

每組測試資料的第一列，有一個整數 n（2 <= n <= 20），代表共有多少種幣種。

接下來的 n 列代表這n種外幣之間的匯率轉換表。每列有 n-1 個數。這 n-1 個數分別代表該幣種1元可以換取其他幣種多少元（自己換自己當然是 1，所以不會出現）。所以第1列的 n-1 個數依序分別代表第1種外幣1元可以換取，第2種外幣，第3種外幣，第4種外幣…第n種外幣各多少元。而第2列的 n-1 個數依序分別代表第2種外幣1元可以換取，第1種外幣，第3種外幣，第4種外幣…第n種外幣各多少元。依此類推，第n列的 n-1 個數依序分別代表第n種外幣1元可以換取，第1種外幣，第2種外幣，第3種外幣…第n-1種外幣各多少元。

請參考Sample Input。

Output

對每組測試資料輸出一列，代表一連串幣種轉換的動作，並且套匯獲利需大於 1%（ > 0.01）。如果有不止一種轉換可以獲取超過 1%的利益，請輸出轉換次數最少的。如果轉換次數最少的不止一種，那麼任何一種都可以。請注意：在這裡只要求轉換次數最少，並沒有要求獲利要最大，只要能大於 1% 就可以了。

另外，國稅局還規定最多只能轉換 n 次（n 是幣種的數目）。像 1, 2, 1 這樣的轉換次數為 2。

如果在 n 次的轉換內都無法獲利超過 1%，請輸出 no arbitrage sequence exists。

Sample Input
3
1.2 .89
.88 5.1
1.1 0.15
4
3.1 0.0023 0.35
0.21 0.00353 8.13
200 180.559 10.339
2.11 0.089 0.06111
2
2.0
0.45

Sample Output

1 2 1
1 2 4 1
no arbitrage sequence exists

#include <bits/stdc++.h>
using namespace std;
//fstream in,out;
const int inf=99999;
double dp[21][21][21],mark[21][21][21];
double rate[21][21];
int p;
void get_path(int i,int j,int s)
{
    if(s==0)
    {
        cout<<i;
        return;
    }
    get_path(i,mark[i][j][s],s-1);
    cout<<" "<<j;
}
int main()
{
    ios::sync_with_stdio(false);
    int n,s;
    while(cin>>n)
    {
        memset(mark,0,sizeof(mark));
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(i==j)
                {
                    rate[i][j]=1;
                    dp[j][i][1]=1;
                }
                else
                {
                    cin>>rate[i][j];
                    dp[i][j][1]=rate[i][j];
                    mark[i][j][1]=j;
                }
            }
        }
        for(s=2;s<=n;s++)
        {
            for(int k=1;k<=n;k++)
            {
                for(int i=1;i<=n;i++)
                {
                    for(int j=1;j<=n;j++)
                    {
                        if(dp[i][j][s]<dp[i][k][s-1]*rate[k][j])
                        {
                            dp[i][j][s]=dp[i][k][s-1]*rate[k][j];
                            mark[i][j][s]=k;
                        }
                    }
                }
            }
            int i;
            for(i=1;i<=n;i++)
            {
                if(dp[i][i][s]>1.01)
                {
                    p=i;
                    break;
                }
            }
            if(i<=n)
                break;
        }
        if(s>n)
            cout<<"no arbitrage sequence exists";
        else
            get_path(p,p,s);
        cout<<endl;
    }
    return 0;
}

解答:
在lrj的白书上寻思找道图论的题做做，结果是一道动态规划= =orz
这题想了半天，想到了用floyed算法的改进，但是卡在了如何保证套汇小于0.01的情况下。刚开始的思路设置dp[i][j]为从i种钱币套汇到j种钱币的利率，设置sum[i][j]为从i套汇到j的交换次数，然后打算在每次计算dp[i][j]满足大于0.01的同时计算计算sum[i][j]，并找出最小的，想到半道发现这种想法有缺陷，因为在dp[i][j]在进行状态转移的时候参考的条件是sum[i][j]，所以dp[i][j]获得的并不是最优解。后来想到增加状态的方法，但是没继续想下去，如果继续想说不定就做出来了，可惜这么一道好题。总结一句话：
如果一个子问题在受到限制无法转移到最优解，或者要求在某个条件s下得到最优值dp[i][j][k]…，那么首先应该考虑增加一个状态s变成dp[i][j][k]…[s]来处理！

代码参考了大神的博客：http://www.cnblogs.com/scau20110726/archive/2012/12/26/2834674.html

以下是引用大神博客中的话：

DP构建（仿照Floyd）

这题说难挺难的，现在想想好像也不太难，是因为想复杂了。其实这题的要求不算多，它仅仅是要求最后转换回到出发时的那种硬币并且获利大于0.01，而转换次数不能超过n次，转换次数越少越好，然后输出最短的路径。注意：题目并没有说要你获利最大，只是是获利>=0.01即可，另外题目对路径并没有什么特殊要求，仅仅是要求不能超过n，在路径长度相同的情况任意一条都可以的。

所以我们就抓住一点：转换次数！！！！！！

也就是说每转换一次，我们就去找所有的货币，看他们回到自己的时候那些货币的获利已经大于0.01了，如果有货币的获利已经大于0.01了，那么我们的算法就结束了，就输出这种货币的转换路径（就算有多种货币的获利都大于0.01都好，输出哪种货币都行，因为题目也没有要求）

我们应该写一个最外层的循环，是表示第几次转换的，这个循环不能大于n，因为最多只能转换n次不管成功还是失败都要结束

然后，用转换次数来做最外层的循环这个策略是正确的，为什么呢？假设当前是第i+1次转换，那么是需要用到第i次转化的信息的！！！

为什么呢？我们可以回顾一下Floyd的本质。

原本的Floyd是一个三维数组 dp[k][i][j]=max{ dp[k-1][i][j] , dp[k-1][i][k]+dp[k-1][k][j] }

我们平时写的Floyd都是二维的，其实是三维的压缩回来的，没什么能压缩掉最高的那一维呢？单单看状态转移方程都可能看出来，当前要构建的dp[k][i][j]其实只和之前的dp[k-1][][]有关，也就是现在的信息完全是基于前一次的信息推导出来的。这就像我们的滚动数组一样

所以我们来定义个状态dp[i][j][s] i和j就是第i种和第j种货币，s是转换次数，s从1开始到n。也就是说，在第s次转换中，试图从i转化内j

那么状态转移方程是什么呢？ dp[i][j][s]=max{ dp[i][j][s-1] , dp[i][k][s-1]*g[k][j]}

g[i][j]是输入的数据也就是两两货币之间的转化率，其实可以保存在dp[i][j][0]里面

那么这个状态转移方程是什么意思呢？就是说在前一次转化后，现在想从i转换到j，试图通过k，看能不能让值更大，能的话就变大（变大一定不吃亏，因为题目也没要求货币变成多少，只是要求要大于0.01，所以当前要是能变大的话那当然变大）