HDOJ 4571 Travel in time

题意：给n个城市，m条路径，表示从a->b需要t时间，每个城市有一个满意度si，游览这个城市需要花费ti时间，若经过城市不游览则不需要花费时间，且后访问的城市的满意度必须比前一个城市高。已知起点与终点，求在花费T时间的时限内，能够获得的最大的满意度。

链接：http://acm.hdu.edu.cn/showproblem.php?pid=4571

思路：先用floyd求出城市之间的最短距离，剩下在有限的T时间内得到尽可能多的满意度，用01背包即可。状态转移方程为：

注意点：对结构体排序后，下标改变，需要用一个额外数组对下标进行存储，便于快速查找i节点。

以下为AC代码：

Run ID	Submit Time	Judge Status	Pro.ID	Exe.Time	Exe.Memory	Code Len.	Language	Author
12535950	2014-12-18 19:14:02	Accepted	4571	982MS	1332K	3217 B	C++	luminous11

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <deque>
#include <list>
#include <cctype>
#include <algorithm>
#include <climits>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <set>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#define ll long long
#define ull unsigned long long
#define all(x) (x).begin(), (x).end()
#define clr(a, v) memset( a , v , sizeof(a) )
#define pb push_back
#define mp make_pair
#define read(f) freopen(f, "r", stdin)
#define write(f) freopen(f, "w", stdout)
using namespace std;

struct node
{
    int p;
    int sati;
    int t;
    node() {}
    bool operator < ( const node& a )const
    {
        return sati < a.sati;
    }
}adj[1005];

int m, n, s, t, e;
int maxn;
int g[105][105];
int dp[105][305];
int h[105];
int vis[105];

void floyd ( )
{
    for ( int i = 0; i < n; i ++ )
    {
        for ( int j = 0; j < n; j ++ )
        {
            for ( int k = 0; k < n; k ++ )
            {
                if ( g[j][k] > g[j][i] + g[i][k] )
                {
                    g[j][k] = g[j][i] + g[i][k];
                }
            }
        }
    }
}

int solve ( )
{
    for ( int i = 0; i < n; i ++ )
    {
        for ( int j = adj[i].t + g[i][s]; j <= t; j ++ )
        {
            dp[i][j] = adj[i].sati;
        }
    }
    for ( int i = 0; i < n; i ++ )
    {
        for ( int j = 0; j < i; j ++ )
        {
            if ( adj[i].sati == adj[j].sati )break;
            for ( int k = adj[i].t + g[i][j]; k <= t; k ++ )
            {
                if ( dp[j][k - adj[i].t - g[i][j]] == -1 )continue;
                dp[i][k] = max ( dp[i][k], dp[j][k - adj[i].t - g[i][j]] + adj[i].sati );
            }
        }
    }
    int ans = 0;
    for ( int i = 0; i < n; i ++ )
    {
        for ( int j = 0; j <= t; j ++ )
        {
            if ( j + g[i][e] > t )break;
            ans = max ( ans, dp[i][j] );
        }
    }
    return ans;
}

void init ()
{
    clr ( adj,  0  );
    clr (  g, 0x3f );
    clr ( dp,  -1  );
    maxn = 0;
}

int main()
{
    int ncase;
    cin >> ncase;
    for ( int ti = 1; ti <= ncase; ti ++ )
    {
        init();
        cin >> n >> m >> t >> s >> e;
        for ( int i = 0; i < n; i ++ )
        {
            cin >> adj[i].t;
        }
        for ( int i = 0; i < n; i ++ )
        {
            cin >> adj[i].sati;
            adj[i].p = i;
            g[i][i] = 0;
        }
        sort ( adj, adj + n );
        for ( int i = 0; i < n; i ++ )
        {
            h[adj[i].p] = i;
        }
        s = h[s];
        e = h[e];
        int a, b, len;
        for ( int i = 0; i < m; i ++ )
        {
            cin >> a >> b >> len;
            a = h[a];
            b = h[b];
            if ( g[a][b] > len )
            {
                g[a][b] = g[b][a] = len;
            }
        }
        floyd ();

        cout << "Case #" << ti << ":" << endl;
        if ( g[s][e] > t ){ cout << "0" << endl; continue;}
        cout << solve () << endl;
    }
    return 0;
}