Hiho coder: #1200 : Increase Charisma Points

时间限制:10000ms

单点时限: 1000ms

内存限制: 256MB

描述

Little Ho is playing a role-playing game. There are N cities in the game which are numbered from 1 to N. Every time Little Ho moves to another city his charisma (a kind of character attribute) will increase by 1 point no matter whether the city is visited before. For example if Little Ho’s moving path is 1->2->3->2->3->1 his charisma will increase by 5.

Little Ho wants to maximize his charisma. However moving between cities costs action points. More precisely moving from city i to city j costs him Aij action points. Little Ho wants to know how many points of charisma he can get by using no more than M action points? He may start at any city.

输入

Line 1: N and M, the number of cities and the initial action points.

Line 2~N+1: An N x N matrix A. Aij is the action point cost as described above.

For 30% of the data: 2≤N≤5，1≤M≤50，0≤Aij≤10

For 60% of the data: 2≤N≤50，1≤M≤2000，0≤Aij≤10

For 100% of the data: 2≤N≤100，1≤M≤1,000,000,000，0≤Aij≤20

输出

The maximum points of charisma Little Ho can get.

样例提示

The optimal path is 1->2->3->1->2.

样例输入

3 10
0 2 3
4 0 2
3 4 0

样例输出

4

算法分析：

        显然，可以修改floyd算法，定义一个如下的状态方程

        dp(i,j,k)表示图中从i到j走k步的最小代价，则有如下的状态转移方程

        dp(i,j,k)=min{dp(i,l,k-1)+dp(l,j,k-1) for l = 0,1,2,...n-1}

        至于原问题的解，我们可以使用二分查找，即给定一个步数s，我们判断在s步内是否存在两个点i,j，使得从i走s步到j，并使用的代价不大于M。

代码：

#include 
#include 
#include 
#include 
using namespace  std;

unsigned int NXUpperPow2(unsigned int v){
    --v;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    return ++v;
}

unsigned int NXLowerPow2(unsigned int x){
    unsigned int v = NXUpperPow2(x);
    return v == x ? v : v >> 1;
}

unsigned int NXPow2(unsigned int x){
    int bc = 0;
    while(x){
        ++bc;
        x >>= 1;
    }
    return bc;
}

class Matrix{
public:
    friend inline Matrix operator * (const Matrix &lhs, const Matrix &rhs);
    friend inline Matrix QuickPow(const int n);
public:
    explicit Matrix(int iScale);
    Matrix();
public:
    vector& operator[] (const int idx){
        return m_Elem[idx];
    }
    
    const vector & operator[] (const int idx) const{
        return m_Elem[idx];
    }
    
    void SetScale(int iScale);
public:
    vector > m_Elem;
    int          m_iScale;
};

Matrix pm[32];

class Solution{
public:
    bool ReadData();
    int GetResult();
private:
    bool Check(const Matrix &m);
public:
    int N;
    int M;
    Matrix cost;
};

inline Matrix operator * (const Matrix &lhs, const Matrix &rhs){
    int iScale = lhs.m_iScale;
    int mv;
    Matrix result(iScale);
    for(int r = 0; r < iScale; ++r){
        for(int c = 0; c < iScale; ++c){
            result[r][c] = -1;
            for(int k = 0; k < iScale; ++k){
                if(lhs[r][k] == -1 || rhs[k][c] == -1){
                    continue;
                }
                mv = lhs[r][k] + rhs[k][c];
                if(mv < result[r][c])
                    result[r][c] = mv;
            }
        }
    }
    return result;
}

inline Matrix QuickPow(const int n){
    if(n == 1){
        return pm[0];
    }
    int p2 = NXLowerPow2(n);
    int l2 = NXPow2(n);
    return p2 == n ? pm[l2 - 1] : pm[l2 - 1] * QuickPow(n - p2);
}

Matrix::Matrix(int iScale){
    SetScale(iScale);
}

Matrix::Matrix(){
    
}

void Matrix::SetScale(int iScale){
    m_iScale = iScale;
    m_Elem.resize(iScale);
    for(int i = 0; i < iScale; ++i){
        m_Elem[i].resize(iScale);
    }
}

bool Solution::ReadData(){
    if(! (cin >> N)){
        return false;
    }
    
    cin  >> M;
    cost.SetScale(N);
    for(int r = 0; r < N; ++r){
        for(int c = 0; c < N; ++c){
            cin >> cost[r][c];
        }
        cost[r][r] = -1;
    }
    pm[0] = cost;
    int l = NXPow2(M);
    for(int i = 1; i < l; ++i){
        pm[i] = pm[i- 1] * pm[i - 1];
    }
    return true;
}

bool Solution::Check(const Matrix &m){
    for(int r = 0; r < N; ++r){
        for(int c = 0; c < N; ++c){
            if(m[r][c] <= M){
                return true;
            }
        }
    }
    
    return false;
}

int Solution::GetResult(){
    if(!Check(cost)){
        return 0;
    }
    
    int l = 1, r = M;
    int m;
    while(l < r){
        m = (l + r) >> 1;
        if(Check(QuickPow(m))){
            l = m + 1;
        }else{
            r = m - 1;
        }
    }
    while(!Check(QuickPow(l))){
        --l;
    }
    return l;
}

int main(){
    Solution so;
    while(so.ReadData()){
        cout << so.GetResult() << endl;
    }
}