HDOJ-2614 Beat bfs广搜

题目：

Beat

Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2449    Accepted Submission(s): 1400

 

Problem Description

Zty is a man that always full of enthusiasm. He wants to solve every kind of difficulty ACM problem in the world. And he has a habit that he does not like to solve
a problem that is easy than problem he had solved. Now yifenfei give him n difficulty problems, and tell him their relative time to solve it after solving the other one.
You should help zty to find a order of solving problems to solve more difficulty problem. 
You may sure zty first solve the problem 0 by costing 0 minute. Zty always choose cost more or equal time’s problem to solve.

 

 

Input

The input contains multiple test cases.
Each test case include, first one integer n ( 2< n < 15).express the number of problem.
Than n lines, each line include n integer Tij ( 0<=Tij<10), the i’s row and j’s col integer Tij express after solving the problem i, will cost Tij minute to solve the problem j.

 

 

Output

For each test case output the maximum number of problem zty can solved.

 

 

 

Sample Input

3 0 0 0 1 0 1 1 0 0 3 0 2 2 1 0 1 1 1 0 5 0 1 2 3 1 0 0 2 3 1 0 0 0 3 1 0 0 0 0 2 0 0 0 0 0

 

 

Sample Output

3 2 4

题意：

Zty做题，有n道题，给定一个n*n的矩阵，T[i][j]表示做完题i后做题j需要花费的时间，Zty做题只做比他做的上一道题花费时间多的题目，问他最多能做多少道题。

分析：

bfs广搜，题目被做出来的状态会改变，可以直接将其储存在节点中，也可以用状态压缩进行储存。

代码：

#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<queue>
using namespace std;

int N;
int G[16][16];
bool vis[16];
struct node{
    int val,id,sum;
    bool v[16];//直接将题目被做出来的状态储存在节点中，用状态压缩更好
};

int bfs(){
    queue<node> q;
    node st;
    st.val = 0;
    st.id = 0;
    st.sum = 1;
    memset(st.v,false,sizeof(st.v));
    st.v[0] = true;
    q.push(st);
    int ans = 1;
    while(!q.empty()){
        node cur = q.front();
        q.pop();
        for(int i=0;i<N;i++){
            node nex;
            nex.id = i;
            nex.val = G[cur.id][i];
            nex.sum = cur.sum;
            if(cur.v[nex.id] || nex.val < cur.val) continue;
            memcpy(nex.v,cur.v,sizeof(cur.v));
            nex.v[nex.id] = true;
            nex.sum++;
            if(nex.sum>ans) ans = nex.sum;
            q.push(nex);
        }
    }
    return ans;
}

int main(){
    while(cin >> N){
        for(int i=0;i<N;i++){
            for(int j=0;j<N;j++){
                cin >> G[i][j];
            }
        }

        int res = bfs();
        cout << res << endl;
        //cout << endl;
    }
    return 0;
}