HDU6223 Infinite Fraction Path bfs+剪枝

Infinite Fraction Path

这个题第一次看见的时候，题意没搞懂就没做，这第二次也不会呀。。

题意：第i个城市到第(i*i+1)%n个城市，每个城市有个权值，从一个城市出发走N个城市，就可以得到一个长度为N的权值序列，求字典序最大的序列。

首先因为每个城市的出度为1，所以从任意城市出发都可以走出N步，通过打表可以发现度数为0的点几乎占了10分之9，也就是说大部分都是相同重复的部分。

虽然经过了一系列分析，但这并没有任何用，写了一发暴力dfs，T了。然后题解做题法，有几个解法，一个是鲲鲲有想到，但是卡常，我也不会。然后第二个就是bfs+剪枝。

有想到是搜索+剪枝，但一直想是怎么dfs记忆化，唉，太菜了。然后bfs很好理解，我们就按照深度的优先级一层层向下走，然后第一个剪枝就是，当前层已经保存的答案要是大于目前这个位置的权值，

那么很明显当前这个位置没必要扩展下去了，然后如果这个位置已经到过比现在更深的深度，那么有当前深度当那个深度之间的答案，已经被更新过了，那也没必要扩展了。

#include<cstdio>
#include<queue>
using namespace std;
const int N=2e5+11;
char mp[N];
int n,maxv,ne[N],dep[N],val[N],ans[N];
struct Node{
    int pos,dep;
    Node(){}
    Node(int pos,int dep):pos(pos),dep(dep){}
    bool operator<(const Node &n1)const{
        return dep==n1.dep ? val[pos]<val[n1.pos] : dep>n1.dep;
    }
}qn;
void init(){
    maxv=0;
    for(int i=0;i<=n;i++){
        dep[i]=ans[i]=-1;
        val[i]=mp[i]-'0';
        maxv=max(maxv,val[i]);
        ne[i]=(1ll*i*i+1)%n;
    }
}
void bfs(){
    priority_queue<Node> q;
    for(int i=0;i<n;i++) 
        if(val[i]==maxv) q.push(Node(i,0));
    while(!q.empty()){
        qn=q.top();
        q.pop();
        if(ans[qn.dep]==-1) ans[qn.dep]=val[qn.pos];
        else if(ans[qn.dep]>val[qn.pos]) continue;
        if(dep[qn.pos]<qn.dep) dep[qn.pos]=qn.dep;
        else continue;
        if(qn.dep==n-1) continue; 
        q.push(Node(ne[qn.pos],qn.dep+1)); 
    }
}
int main(){
    int t=1,T;
    scanf("%d",&T);
    while(t<=T){
        scanf("%d",&n);
        scanf("%s",mp);
        init();
        bfs();
        printf("Case #%d: ",t++);
        for(int i=0;i<n;i++) printf("%d",ans[i]);
        printf("\n");
    }
    return 0;
}