Mem468

DIV2

250的题过以前难了一点点，submit的很顺利，500的题很长，看了半天，没看懂，再者，见到那字符串就没啥胃口了，看1000的题，想了想，有了思路，但不确定是否可以，那个时候还40来分钟吧，然后就悲剧了，写的很搓，手慢。到Challenge结束后，才写完并Debug完，看DIV2中过的人，也是那样类似哈密顿DP的方法过的。

大意：有张图，记顶点1...n,A,B，要让A尽可能经过1..n中的点，然后到达B，但从Xi到Xj的费用是map[i][j] * (1 + cnt()),cnt()表示之前已经经过1..n中的点的数目，然后从这个过程有一个时间限制T。

然后就先建图，这里把我的精神写搓掉了，然后DP[i][j]，i表示状态,j表示最后停在j点处的时间，要让这个尽可能小，最后就是DP[i][j]，然后枚举状态i，找出到达B处的，时间在要求内，并且点数最多即可。

这些都是基于点数较少，可能枚举出所有的情况，这样想，跟哈密顿DP法就如出一辙了。

注意longlong以及dp[i][j]==-1的要continue掉，路径的费用要算对。

#include <iostream>
#include <string>
#include <algorithm>
#include <string.h>
#include <vector>
#include <math.h>
#include <time.h>
#include <queue>
#include <set>
 using namespace std;

const long long MAX = 55;
const long long INF = 1000000001;

struct NODE
{
    long long x, y;
    long long t;
    NODE() {}
    NODE(long long xx, long long yy, long long tt) : x(xx), y(yy), t(tt) {}
};

long long map[MAX][MAX];//distance
long long vetex[MAX][MAX];//flag
long long nodeCnt;
long long n;
long long citySizeX;
long long citySizeY;
long long move[4][2] = {-1, 0, 0, 1, 1, 0, 0, -1};
long long path[1 << 16][20];

long long dp[1 << 16][20];

bool check(long long x, long long y)
{
    if(x < 0 || y < 0 || x >= citySizeX || y >= citySizeY)  return false;
    if(vetex[x][y] == -1)  return false;
    return true;
}

long long oneCnt(long long x)
{
    long long res = 0;
    while(x)
    {
        if(x & 1)  res++;
        x >>= 1;
    }
    return res;
}

void bfs(long long x, long long y, long long ss)
{
    vector<NODE>q;
    long long s[MAX][MAX];
    memset(s, 0, sizeof(s));
    s[x][y] = 1;
    q.push_back(NODE(x, y, 0));
    for(long long i = 0; i < q.size(); i++)
    {
        for(long long j = 0; j < 4; j++)
        {
            long long xx = q[i].x + move[j][0];
            long long yy = q[i].y + move[j][1];
            if(check(xx, yy) && s[xx][yy] == 0)
            {
                s[xx][yy] = 1;
                if(vetex[xx][yy] > 0)  map[ss][vetex[xx][yy]] = q[i].t + 1;
                q.push_back(NODE(xx, yy, q[i].t + 1));
            }
        }
    }
}

void show(long long i)
{
    while(i)
    {
        printf("%d", i & 1);
        i >>= 1;
    }
    printf("\n");
}

void dfs(long long i, long long j)
{
    while(1)
    {
        printf("#%d\n", j + 1);
        if(path[i][j] == -1)  break;
        long long t = path[i][j];
        i = t / 100;
        j = t % 100;

    }
    
    for(i = 1; i <= nodeCnt; i++)
    {
        for(long long j = 1; j <= nodeCnt; j++)
        {
            printf("%d ", map[i][j]);
        }
        printf("\n");
    }
}

long long go(vector <string> city, long long T)
{
    nodeCnt = 0;
    citySizeX = city.size();
    citySizeY = city[0].size();
    long long i, j;
    long long ki, kj, qi, qj;
    for(long long i = 0; i < city.size(); i++)
    {
        for(long long j = 0; j < city[i].size(); j++)
        {
            if(city[i][j] == '.')  vetex[i][j] = 0;
            else if(city[i][j] == '#')  vetex[i][j] = -1;
            else if(city[i][j] == 'K')  
            {
                ki = i, kj = j;
            }
            else if(city[i][j] == 'Q')  qi = i, qj = j;
            else if(city[i][j] == 'G')  vetex[i][j] = ++nodeCnt;
        }
    }
    vetex[ki][kj] = ++nodeCnt;
    vetex[qi][qj] = ++nodeCnt;
    n = nodeCnt - 2;

    //get distance
    for(long long i = 1; i <= nodeCnt; i++)
    {
        for(long long j = 1; j <= nodeCnt; j++)
        {
            if(i == j)  map[i][j] = 0;
            else  map[i][j] = INF;
        }
    }
    for(long long i = 0; i < city.size(); i++)
    {
        for(long long j = 0; j < city[i].size(); j++)
        {
            if(vetex[i][j] > 0)  bfs(i, j, vetex[i][j]);
        }
    }

    memset(dp, -1, sizeof(dp));
    memset(path, -1, sizeof(path));
    for(long long i = 0; i < n; i++)
    {
        dp[1 << i][i] = map[n + 1][i + 1];
    }
    for(long long i = 0; i < (1 << n); i++)
    {
        for(long long j = 0; j < n; j++)
        {
            if((1 << j) & i)
            {
                if(dp[i][j] == -1)  continue;
                for(long long kk = 0; kk < n; kk++)
                {
                    if(kk == j)  continue;
                    if((1 << kk) & i)  continue;
                    if(map[j + 1][kk + 1] == INF)  continue;
                    long long num = oneCnt(i);
                    if(dp[i + (1 << kk)][kk] == -1 || dp[i][j] + map[j + 1][kk + 1] * (1 + num) < dp[i + (1 << kk)][kk])
                    {
                        dp[i + (1 << kk)][kk] = dp[i][j] + map[j + 1][kk + 1] * (1 + num);
                        path[i + (1 << kk)][kk] = i * 100 + j;
                    }
                }
            }
        }
    }

    long long ans = 0;
    for(long long i = 0; i < (1 << n); i++)
    {
        for(long long j = 0; j < n; j++)
        {
            if((1 << j) & i)
            {
                if(dp[i][j] == -1)  continue;
                if(dp[i][j] + map[j + 1][n + 2] * (1 + oneCnt(i)) <= T)
                {
                    if(oneCnt(i) > ans)
                    {
                        ans = oneCnt(i);
                        if(ans == 4)  
                        {
                            show(i);
                            dfs(i, j);
                        }
                    }
                }
            }
        }
    }
    return ans;
}

class Gifts
{
public:
    int maxGifts(vector <string> city, int T)
    {
        return go(city, T);
    }
};