NOIP2017 题解
QAQ……由于没报上名并没能亲自去，自己切一切题聊以慰藉吧……
可能等到省选的时候我就没有能力再不看题解自己切省选题了……辣鸡HZ毁我青春
D1T1 小凯的疑惑
地球人都会做，懒得写题解了……
D1T2 时间复杂度
分类讨论+递归就行了，没啥思维含量，略。
D1T3 逛公园
这题好劲啊……
看见\(k\le 50\)应该能想到这是一个\(O((n+m)k)\)的DP，由于题目要求的是比最短路长度长至多\(k\)的路径条数，因此状态定义应该是定义\(f_{i,j}\)表示从\(i\)走到终点，长度为\(i\)到终点的最短路长度+\(j\)的路径条数（如果你习惯倒序定义的话）。
转移方程也不难写出：
其中\(d_i\)表示\(i\)到终点的最短路长度，边界是\(f_{n,0}=1\)。
注意到这个转移方程存在同层转移的问题：
定义最短路DAG是所有点和所有满足\(d_i=d_j+w\)的边\(<i,j>,w\)组成的图（当然由于零边的存在，这个图上可能会有零环），那么转移时所有最短路DAG上的边都会有同层转移的问题。
如果有一个可以到达（总路程不超过\(D+k\)）的零环那显然答案就应该是-1了。因此我们可以对最短路DAG进行拓扑排序，最后能出来的点（也就是不能沿最短路到达零环的点）一定组成一个DAG。
所以只需要判断那些出不来（在零环上或者通向零环）的点是否可达就行了。如果答案不是-1的话就只需要转移那些能出来的点，为了解决同层转移的问题，对每层先从低层转移过来，再按照最短路DAG的拓扑序同层转移即可。这样做不需要递归，常数比记忆化搜索小很多。
（注意由于数据范围比较大，最开始求\(d_i\)和构造最短路DAG时要用Dijkstra算法，不要用SPFA。）
莫名其妙的地方都能写错，老年选手身败名裂……
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
const int maxn=100005,maxm=200005;
struct A{
int x,d;
A(int x,int d):x(x),d(d){}
bool operator<(const A &a)const{return d>a.d;}
};
void Dijkstra(int);
void bfs();
vector<int>G[maxn],W[maxn],G2[maxn],RG2[maxn];
bool vis[maxn];
int d[maxn],dis[maxn],du[maxn],q[maxn],u[maxm],v[maxm],w[maxm];
int T,n,m,k,p,f[maxn][55],head,tail;
int main(){
scanf("%d",&T);
while(T--){
memset(du,0,sizeof(du));
memset(f,0,sizeof(f));
scanf("%d%d%d%d",&n,&m,&k,&p);
for(int i=1;i<=n;i++){
G[i].clear();
W[i].clear();
G2[i].clear();
RG2[i].clear();
}
for(int i=1;i<=m;i++){
scanf("%d%d%d",&u[i],&v[i],&w[i]);
G[v[i]].push_back(u[i]);
W[v[i]].push_back(w[i]);
}
Dijkstra(n);
memcpy(d,dis,sizeof(d));
for(int i=1;i<=n;i++){
G[i].clear();
W[i].clear();
}
for(int i=1;i<=m;i++){
G[u[i]].push_back(v[i]);
W[u[i]].push_back(w[i]);
}
Dijkstra(1);
for(int i=1;i<=m;i++)if(d[u[i]]==d[v[i]]+w[i]){
//printf("(%d,%d) w=%d\n",u[i],v[i],w[i]);
G2[u[i]].push_back(v[i]);
RG2[v[i]].push_back(u[i]);
du[u[i]]++;
}
bfs();
bool bad=false;
for(int i=1;i<=n;i++)if(!vis[i]&&d[i]+dis[i]<=d[1]+k){
bad=true;
break;
}
if(bad){
printf("-1\n");
continue;
}
//for(int i=1;i<=n;i++)if(!vis[i])printf("d[%d]=%d dis[%d]=%d D=%d k=%d\n",i,d[i],i,dis[i],d[1],k);
f[n][0]=1;
for(int j=0;j<=k;j++){
if(j){
for(int x=1;x<=n;x++)if(vis[x])for(int i=0;i<(int)G[x].size();i++){
int t=d[x]-d[G[x][i]]+j-W[x][i];//printf("%d %d t=%d\n",x,G[x][i],t);
if(t>=0&&t<j){
f[x][j]=f[x][j]+f[G[x][i]][t];
if(f[x][j]>=p)f[x][j]-=p;
}
}
}
for(int i=0;i<tail;i++){
int x=q[i];
for(int t=0;t<(int)G2[x].size();t++){
f[x][j]=f[x][j]+f[G2[x][t]][j];
if(f[x][j]>=p)f[x][j]-=p;
}
}
//for(int i=1;i<=n;i++)printf("f[%d][%d]=%d\n",i,j,f[i][j]);
}
int ans=0;
for(int i=0;i<=k;i++){
ans+=f[1][i];
if(ans>=p)ans-=p;
}
printf("%d\n",ans);
}
return 0;
}
void Dijkstra(int x){
memset(dis,63,sizeof(dis));
memset(vis,0,sizeof(vis));
priority_queue<A>heap;
dis[x]=0;
heap.push(A(x,0));
while(!heap.empty()){
x=heap.top().x;
heap.pop();
vis[x]=true;
for(int i=0;i<(int)G[x].size();i++)if(!vis[G[x][i]]&&dis[G[x][i]]>dis[x]+W[x][i]){
dis[G[x][i]]=dis[x]+W[x][i];
heap.push(A(G[x][i],dis[G[x][i]]));
}
}
}
void bfs(){
head=tail=0;
for(int i=1;i<=n;i++)if(!du[i])q[tail++]=i;
memset(vis,0,sizeof(vis));
while(head!=tail){
int x=q[head++];//printf("%d ",x);
vis[x]=true;
for(int i=0;i<(int)RG2[x].size();i++)if(!--du[RG2[x][i]])q[tail++]=RG2[x][i];
}
//printf("\n");
}
D2T1 奶酪
\(O(n^2)\)暴力就行了，水题。
D2T2 宝藏
看到数据范围一眼\(O^*(3^n)\)状压DP，其中\(3^n\)来自枚举子集的子集。做法好像有很多，比如ryf的做法就比我快了10倍……日渐辣鸡的窝
定义\(f_{i,j,S}\)表示以\(i\)为根的子树，\(i\)在整棵树里的深度是\(j\)，集合\(S\)中的所有点都在这棵子树中时这棵子树的最小总代价。
不难写出转移方程：
（这个转移方程是在枚举与\(i\)相邻的一个点\(k\)并把以\(k\)为根的子树分出去）
然而你发现这个DP是\(O(n^3 3^n)\)的，并不能跑过去。
考虑优化转移，如果把转移方程中与\(S\)无关的部分拿出来并定义一个辅助数组
的话，我们就可以把状态转移方程改写成
这样就可以把复杂度降到\(O(n^2 3^n)\)了，由于常数不大，并不需要卡常。
#include<cstdio>
#include<cstring>
#include<algorithm>
#define bit(x) (1<<((x)-1))
using namespace std;
const int INF=0x3f3f3f3f;
int n,m,w[15][15],f[15][15][(1<<12)+1],g[15][15][(1<<12)+1];
int main(){
scanf("%d%d",&n,&m);
memset(w,63,sizeof(w));
memset(f,63,sizeof(f));
memset(g,63,sizeof(g));
while(m--){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
w[x][y]=w[y][x]=min(w[x][y],z);
}
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)f[i][j][bit(i)]=0;
for(int j=n-1;j;j--)for(int s=0;s<(1<<n);s++)for(int i=1;i<=n;i++){
for(int k=1;k<=n;k++)if((bit(k)|s)==s&&w[i][k]<INF)
g[i][j][s]=min(g[i][j][s],f[k][j+1][s]+w[i][k]*j);
for(int t=s&(s-1);;(--t)&=s){
f[i][j][s]=min(f[i][j][s],f[i][j][s^t]+g[i][j][t]);
if(!t)break;
}
}
int ans=INF;
for(int i=1;i<=n;i++)ans=min(ans,f[i][1][(1<<n)-1]);
printf("%d",ans);
return 0;
}
D2T3 列队
这题真是劲啊……比往年的数据结构NB到不知哪儿去了……
（码力太差还没写出来，写出来之后再补题解）
