http://acm.nefu.edu.cn/JudgeOnline/index.php
A.时空乱流
n个空间，要建设空间站，每个空间都能传送到另外一个空间，在每个空间建设空间站需要一个权值，求无论在哪个空间，都能到达有空间站的空间所需要建设空间站的最小权值。
比赛的时候，想到了并查集，但空间是单向的，不对，想到了tarjan，但没想到缩点，最后一直在想dfs，也没想出来，比完赛，看到学长题解里的缩点，立马就做出来了。。。。
还是做题做的太少了。。
tarjan
#include<cstdio>
#include<algorithm>
#include<cstring>
#define maxn 200010
using namespace std;
struct node
{
int v,next;
} edge[maxn];
int DFN[maxn],LOW[maxn];
int stack[maxn],heads[maxn],visit[maxn],cnt,tot,indexx,num;
int color[maxn],a[maxn],outd[maxn],val[maxn];
void add(int x,int y)
{
edge[++cnt].next=heads[x];
edge[cnt].v = y;
heads[x]=cnt;
}
void tarjan(int x)
{
DFN[x]=LOW[x]=++tot;
stack[++indexx]=x;
visit[x]=1;
for(int i=heads[x]; i!=-1; i=edge[i].next)
{
if(!DFN[edge[i].v])
{
tarjan(edge[i].v);
LOW[x]=min(LOW[x],LOW[edge[i].v]);
}
else if(visit[edge[i].v])
{
LOW[x]=min(LOW[x],DFN[edge[i].v]);
}
}
if(LOW[x]==DFN[x])
{
num++;
do
{
visit[stack[indexx]]=0;
color[stack[indexx]]=num;
val[num]=min(val[num],a[stack[indexx]]);
indexx--;
}
while(x!=stack[indexx+1]);
}
}
void init()
{
memset(heads,-1,sizeof(heads));
memset(val,0x3f,sizeof(val));
memset(edge,0,sizeof(edge));
memset(DFN,0,sizeof(DFN));
memset(LOW,0,sizeof(LOW));
memset(color,0,sizeof(color));
memset(visit,0,sizeof(visit));
memset(outd,0,sizeof(outd));
cnt=0;
tot=0;
num=0;
}
int main()
{
int t,n,m;
scanf("%d",&t);
while(t--)
{
init();
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
for(int i=1;i<=n;i++)
{
scanf("%d",&m);
add(i,m);
}
for(int i=1; i<=n; i++)
{
if(!DFN[i])
{
tarjan(i);
}
}
for (int i=1; i<=n; i++)
{
for (int j=heads[i]; j!=-1; j=edge[j].next)
{
if (color[i]!=color[edge[j].v])
{
outd[color[i]]++;
}
}
}
int sum=0;
for (int i=1; i<=num; i++)
{
if (!outd[i])
{
sum+=val[i];
}
}
printf ("%d\n",sum);
}
return 0;
}还有一个dfs的做法，先贴出来
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const ll mod=1e9+7;
int n,cnt;
int a[200005],c[200005];
int v[200005];
int vis[200005];
int dfs(int s,int mm)
{
v[s]=cnt;
vis[s]++;
if (a[s]==s)
return c[s];
else if (v[a[s]]==cnt)
{
if (vis[a[s]]==1)
return dfs(a[s],min(mm,c[a[s]]));
else
return mm;
}
else if (v[a[s]]>0&&v[a[s]]<cnt)
return 0;
else
return dfs(a[s],mm);
}
int main()
{
//freopen("stdin.in","r",stdin);
//freopen("stdout2.out","w",stdout);
int ww;
scanf("%d",&ww);
while (ww--)
{
scanf("%d",&n);
for (int i=1; i<=n; i++)
{
scanf("%d",&c[i]);
}
for (int i=1; i<=n; i++)
{
scanf("%d",&a[i]);
v[i]=0;
vis[i]=0;
}
ll ans=0;
for (int i=1; i<=n; i++)
{
if (!v[i])
{
cnt++;
ans+=dfs(i,INF);
}
}
printf("%lld\n",ans);
}
return 0;
}B.贪吃蛇大作战
dp+离散化+树状数组(线段树)
http://acm.hdu.edu.cn/showproblem.php?pid=6447 杭电P6447
一开始n²建图，dfs，超时，bfs，超时，实在想不出来了，结束后看到题解，离散化，反正也不会，先贴一发代码，慢慢理解
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=1e4+5;
struct data
{
int x,y,z;
bool operator <(const data& v)
{
if (x==v.x)
{
return y>v.y;
}
return x<v.x;
}
}num[maxn];
int t,n;
int m[maxn],a[maxn];
int lowbit(int x)
{
return x&(-x);
}
void add(int x,int ad)
{
for(int i=x;i<=maxn;i+=lowbit(i))
{
m[i]=max(m[i],ad);
}
}
int query(int x)
{
int ans=0;
for(int i=x;i>=1;i-=lowbit(i))
{
ans=max(ans,m[i]);
}
return ans;
}
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
memset(m,0,sizeof(m));
for(int i=1;i<=n;i++)
{
scanf("%d%d%d",&num[i].x,&num[i].y,&num[i].z);
a[i]=num[i].y;
}
sort(a+1,a+n+1);
int sum=unique(a+1,a+n+1)-a-1;
for(int i=1;i<=n;i++)
{
num[i].y=lower_bound(a+1,a+sum+1,num[i].y)-a;
}
sort(num+1,num+n+1);
for(int i=1;i<=n;i++)
{
int res=query(num[i].y-1)+num[i].z;
add(num[i].y,res);
}
printf ("%d\n",query(maxn-1));
}
return 0;
}在hdu上过了，奈何在nefu上就是不过（截至写博客前）
C.青蛙赶路
dp+前缀和
有一只青蛙，每秒选择走1米或跳m米，青蛙体力不足，所以不能连续两秒都在跳。 青蛙将移动到[l,r]之间，它想知道有多少种不同的方式来实现其目标。 两种方式是不同的，当且仅当它们移动不同的米或花费不同的秒，或者是在一秒钟内，其中一个走而另一个跳。
唯一过了的一道题，然后我才知道，负数取余还是负数，
二维数组，一维存位置，二维存是跳还是跑，最后前缀和存一下
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#define ll long long
const int mod=1000000007;
using namespace std;
ll dp[200001][2];
ll sum[200001];
int n,m;
int main()
{
scanf("%d%d",&n,&m);
dp[0][0]=1;
for(int i=1;i<=100001+m;i++)
{
if (i>=m)
{
dp[i][1]=dp[i-m][0]%mod;
}
dp[i][0]=(dp[i-1][0]+dp[i-1][1])%mod;
}
for(int i=1;i<=100001+m;i++)
{
sum[i]=(dp[i][0]+dp[i][1]+sum[i-1])%mod;
}
for(int i=1;i<=n;i++)
{
int l,r;
scanf("%d%d",&l,&r);
printf ("%lld\n",(sum[r]-sum[l-1]+mod)%mod);
}
return 0;
}D.绿巨人吃绿苹果
dp
比赛的时候，我连题都没看懂。。。惭愧。。
题目大意：满k叉树，每个顶点有k条边，边的权重为1~k，现求出从根节点出发，有多少条路径，使得总权值恰好为N，并且每条路径上至少有一条权值不少于d的边。
大概是这样一棵树，这是一颗k=3的树的一部分
很常规简单的dp，其实相当于有数量无限的价值为1,2,3...k的物品，组成总价值为n的，并且至少有一个物品大于d的方法数。
递推方程：dp[当前总价值][已经存在大于d的分支]的方法数=dp[当前总价值-当前分支价值][已经存在大于d的分支]的方法数+dp[当前总价值-当前分支价值][不存在大于d的分支]的方法数（加号后面这一项仅在加如的当前分支的价值大于d时成立）
dp[当前总价值][不存在大于d的分支]的方法数=dp[当前总价值-当前分支价值][不存在大于d的分支]。
学姐的题解写的很明白，代码如下
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=110;
const LL mod=1e9+7;
int n,k,h;
LL dp[maxn][2];
int main()
{
ios::sync_with_stdio();
while(cin>>n>>k>>h){
memset(dp,0,sizeof(dp));
dp[0][0]=1;//第一维:已经拿了多少个苹果，第二维1代表已经存在一个不少于d的分支，0代表一个没有
for(int i=1; i<=n; i++)
for(int j=1; j<=k&&j<=i; j++)
{
dp[i][1]=(dp[i-j][1]+dp[i][1])%mod;
if(j>=h)
{
dp[i][1]=(dp[i-j][0]+dp[i][1])%mod;
continue;
}
dp[i][0]=(dp[i-j][0]+dp[i][0])%mod;
}
cout<<dp[n][1]<<endl;
}
return 0;
}
2645
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
