SRM446 DIV1 500 point

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
using namespace std;

class AntOnGraph {
public:
    string maximumBonus(vector <string>, vector <string>, vector <string>, int, int);
};
const int MAX=120;
const long long INF=1000000000000000000LL;
long long g[MAX][MAX];
long long G[MAX][MAX];
long long tmp[MAX][MAX];
string AntOnGraph::maximumBonus(vector <string> p0, vector <string> p1, vector <string> p2, int stepsPerSecond, int timeLimit) {
    int n=p0.size();
    for(int i=0;i<n;++i)
    {
        for(int j=0;j<n;++j)
        {
            int v=(p0[i][j]-'0')*100+(p1[i][j]-'0')*10+(p2[i][j]-'0')*1;
            if(v==0)
                g[i][j]=-INF;
            else
                g[i][j]=v-500;
        }
    }
    memcpy(G,g,sizeof(G));
    --stepsPerSecond;
    while(stepsPerSecond)
    {
        if(stepsPerSecond&1)
        {
            for(int i=0;i<n;++i)
            {
                for(int j=0;j<n;++j)
                {
                    tmp[i][j]=-INF;
                    for(int k=0;k<n;++k)
                    {
                        if(g[i][k]!=-INF&&G[k][j]!=-INF&&g[i][k]+G[k][j]>tmp[i][j])
                            tmp[i][j]=g[i][k]+G[k][j];
                    }
                }
            }
            memcpy(G,tmp,sizeof(G));
        }
        for(int i=0;i<n;++i)
        {
            for(int j=0;j<n;++j)
            {
                tmp[i][j]=-INF;
                for(int k=0;k<n;++k)
                {
                    if(g[i][k]!=-INF&&g[k][j]!=-INF&&g[i][k]+g[k][j]>tmp[i][j])
                        tmp[i][j]=g[i][k]+g[k][j];
                }
            }
        }
        memcpy(g,tmp,sizeof(g));
        stepsPerSecond/=2;
    }
    memcpy(g,G,sizeof(g));
    --timeLimit;
    while(timeLimit)
    {
        if(timeLimit&1)
        {
            for(int i=0;i<n;++i)
            {
                for(int j=0;j<n;++j)
                {
                    tmp[i][j]=g[i][j];
                    for(int k=0;k<n;++k)
                    {
                        if(g[i][k]!=-INF&&G[k][j]!=-INF&&g[i][k]+G[k][j]>tmp[i][j])
                            tmp[i][j]=g[i][k]+G[k][j];
                    }
                }
            }
            memcpy(g,tmp,sizeof(g));
        }
        for(int i=0;i<n;++i)
        {
            for(int j=0;j<n;++j)
            {
                tmp[i][j]=G[i][j];
                for(int k=0;k<n;++k)
                {
                    if(G[i][k]!=-INF&&G[k][j]!=-INF&&G[i][k]+G[k][j]>tmp[i][j])
                        tmp[i][j]=G[i][k]+G[k][j];
                }
            }
        }
        memcpy(G,tmp,sizeof(G));
        timeLimit/=2;
    }
    if(g[0][1]>-INF)
    {
        char str[1024];
        sprintf(str,"%lld",g[0][1]);
        return str;
    }
    else
        return "IMPOSSIBLE";
}


//Powered by [KawigiEdit] 2.0!