HOJ 13415 Website Tour(强连通缩点+多重背包dp)

题意：每个网站有个广告，看这个广告要花t的时间，能得p的分，最多只能看s次，然后给一些网站以及它所能到达的网站，从一个网站到另一个是不花时间的，但是不能停在同一个网站连续不停的看。现在有T的时间，起点任意，问最大得分。

做法：由于都是有向边，所以我们可以把强连通分量缩点了，这其中的点都可以互相到达，再把这些缩后的点给拓扑排序，就是个DAG了，我们就可以dp了，在这个连通分量的点里面就是多重背包了，可以用二进制分解的办法做到每个点Tlogk的复杂度。然后再去更新它之后的点即可。总复杂度o(n*T*logk+m)。

AC代码：

#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<ctype.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<cstdlib>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<cmath>
#include<ctime>
#include<string.h>
#include<string>
#include<sstream>
#include<bitset>
using namespace std;
#define ll __int64
#define ull unsigned __int64
#define eps 1e-8
#define NMAX 1000000000
#define MOD (1<<30)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define PI acos(-1)
template<class T>
inline void scan_d(T &ret)
{
char c;
int flag = 0;
ret=0;
while(((c=getchar())<'0'||c>'9')&&c!='-');
if(c == '-')
{
flag = 1;
c = getchar();
}
while(c>='0'&&c<='9') ret=ret*10+(c-'0'),c=getchar();
if(flag) ret = -ret;
}
const int maxn = 100+10;
const int maxm = 1000+10;
struct Edge
{
int v,next;
}e[2][maxm];
int head[2][maxn], ecnt[2];
void add_edge(int u, int v, int d)
{
e[d][ecnt[d]].v = v; e[d][ecnt[d]].next = head[d][u];
head[d][u] = ecnt[d]++;
}
struct node
{
int p,t,k;
node(){}
node(int _p, int _t, int _k):p(_p),t(_t),k(_k){}
}no[maxn];
bool zi[maxn];

int pre[maxn], lowlink[maxn], sccno[maxn], dfs_clock, scc_cnt, tp;
int S[maxn];
void dfs(int u)
{
pre[u] = lowlink[u] = ++dfs_clock;
S[++tp] = u;
for(int i = head[0][u]; ~i; i = e[0][i].next)
{
int v = e[0][i].v;
if(!pre[v])
{
dfs(v);
lowlink[u] = min(lowlink[u],lowlink[v]);
}
else if(!sccno[v]) lowlink[u] = min(lowlink[u],pre[v]);
}
if(lowlink[u] == pre[u])
{
scc_cnt++;
while(1)
{
int x = S[tp]; tp--;
sccno[x] = scc_cnt;
if(x == u) break;
}
}
}

void find_scc(int n)
{
tp = -1;
dfs_clock = scc_cnt = 0;
memset(sccno,0,sizeof(sccno));
memset(pre,0,sizeof(pre));
for(int i = 1; i <= n; i++) if(!pre[i])
dfs(i);
}

vector<int>vec[105];

int Em[maxm][2];
bool bian[maxn][maxn];
int in[maxn],top[maxn];
void topo(int n)
{
queue<int>q;
for(int i = 1; i <= n; i++) if(in[i] == 0)
q.push(i);
int k = 1;
while(!q.empty())
{
int x = q.front(); q.pop();
top[k++] = x;
for(int i = head[1][x]; ~i ; i = e[1][i].next)
{
int v = e[1][i].v;
in[v]--;
if(in[v] == 0) q.push(v);
}
}
}
int dp[maxn][10000+10];

node ha[maxn];
int main()
{
#ifdef GLQ
freopen("input.txt","r",stdin);
// freopen("o.txt","w",stdout);
#endif
int n,m,T;
while(~scanf("%d%d%d",&n,&m,&T) && n+m+T)
{
memset(head,-1,sizeof(head));
memset(ecnt,0,sizeof(ecnt));
memset(zi,0,sizeof(zi));
for(int i = 1; i <= n; i++)
scanf("%d%d%d",&no[i].p,&no[i].t,&no[i].k);
for(int i = 1; i <= m; i++)
{
int u,v;
scanf("%d%d",&u,&v);
if(u == v)
{
zi[u] = 1;
Em[i][0] = -1;
}
else
{
Em[i][0] = u;
Em[i][1] = v;
add_edge(u,v,0);
}
}
find_scc(n);
for(int i = 1; i <= scc_cnt; i++) vec[i].clear();
for(int i = 1; i <= n; i++)
{
vec[sccno[i]].push_back(i);
}
for(int i = 1; i <= scc_cnt; i++) if(vec[i].size() == 1 && zi[vec[i][0]] == 0)
no[vec[i][0]].k = 1;
memset(bian,0,sizeof(bian));
memset(in,0,sizeof(in));
for(int i = 1; i <= m; i++) if(Em[i][0] != -1)
{
int u = sccno[Em[i][0]], v = sccno[Em[i][1]];
// cout<<u<<" "<<v<<endl;
if(u != v && bian[u][v] == 0)
{
bian[u][v] = 1;
in[v]++;
add_edge(u,v,1);
}
}
topo(scc_cnt);
for(int i = 1; i <= scc_cnt; i++)
for(int j = 0; j <= T; j++)
dp[i][j] = 0;
for(int i = 1; i <= scc_cnt; i++)
{
int pos = top[i];
int sz = vec[pos].size();
for(int j = 0; j < sz; j++)
{
int id = vec[pos][j];
if(no[id].k*no[id].t >= T)
{
for(int v = no[id].t; v <= T; v++)
dp[pos][v] = max(dp[pos][v],dp[pos][v-no[id].t]+no[id].p);
continue;
}
int cnt = 0;
while((1<<cnt+1)-1 < no[id].k)
{
ha[cnt] = node((1<<cnt)*no[id].p, (1<<cnt)*no[id].t, (1<<cnt));
cnt++;
}
int tt = no[id].k-(1<<cnt)+1;
ha[cnt++] = node(tt*no[id].p, tt*no[id].t, tt);
for(int k = 0; k < cnt; k++)
{
for(int v = T; v >= ha[k].t; v--)
dp[pos][v] = max(dp[pos][v],dp[pos][v-ha[k].t]+ha[k].p);
}
}
for(int j = head[1][pos]; ~j; j = e[1][j].next)
{
int v = e[1][j].v;
for(int val = 0; val <= T; val++)
dp[v][val] = max(dp[v][val],dp[pos][val]);
}
}
int ans = 0;
for(int i = 1; i <= scc_cnt; i++)
ans = max(ans,dp[i][T]);
printf("%d\n",ans);
}
return 0;
}