hdu 6501 transaction transaction transaction 最长路/树形DP/网络流

最长路:

设置一个虚拟起点和虚拟终点，每个点与起点间一条负边，值为这个点书的价值的相反数（代表买书花钱），每个点与终点连一条正边，值为这个点的书的价格（代表卖书赚钱）。

然后按照图中给的边建无向边，权值为负（代表路费）。跑最长路，spfa改一下松弛条件就行

#include<cstdio>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = +;
const int inf = 1e9;
int n;
int cost[+];
struct node
{
    int to;
    int w;
    node(int a,int b):to(a),w(b){}
};
vector<node>G[maxn];
int dist[maxn],vis[maxn];
void spfa()
{
    queue<int>q;
    for(int i=;i<=n+;i++) dist[i] = -inf;
    memset(vis,,sizeof(vis));
    q.push(); vis[] = ; dist[] = ;
    while(!q.empty())
    {
        int u = q.front(); q.pop(); int len = G[u].size();
        for(int i=;i<len;i++)
        {
            int v = G[u][i].to;
            int w = G[u][i].w;
            if(dist[v]<dist[u]+w)
            {
                dist[v] = dist[u] + w;
                if(!vis[v]){vis[v] = ; q.push(v); }
            }
        }
        vis[u] = ;
    }
    printf("%d\n",dist[n+]);
}
int main()
{
    int cases,u,v,w;
    scanf("%d",&cases);
    while(cases--)
    {
        scanf("%d",&n);
        for(int i=;i<n+;i++) G[i].clear();
        for(int i=;i<=n;i++) scanf("%d",&cost[i]);
        for(int i=;i<=n;i++)
        {
            G[].push_back(node(i,-cost[i]));
            G[i].push_back(node(n+,cost[i]));
        }
        for(int i=;i<n;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            G[u].push_back(node(v,-w));
            G[v].push_back(node(u,-w));
        }
        spfa();
    }
    return ;
}

树形DP:

设1为根节点，假设一开始一个人身上的钱为0。

我们设dp[i][0]表示从根节点走到i及其子树并中任一点买入一本书后这个人身上钱的最大值(显然是负的)。

dp[i][1]表示从根节点走到i及其子树并中任一点卖出一本书后这个人身上钱的最大值(可正可负)。

那么我们对这棵树进行一次树形DP即可，dfs后对每个节点更新收益最大值，单点的计算方法为:w=dp[i][0]+dp[i][1]

(由于前者是负的，相当于收入减去总花费)

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)

typedef long long ll;
const int maxn = ;
const ll mod = 1e9+;
const int INF = 0x3f3f3f3f;
const double eps = 1e-;

struct node
{
    int v,w;
    node(int _v,int _w):v(_v),w(_w) {}
};

int n,ans;
int val[maxn];
int dp[maxn][];
vector<node>vec[maxn];

void dfs(int u,int pre)
{
    dp[u][]=-val[u];
    dp[u][]=val[u];
    for(int i=;i<vec[u].size();i++)
    {
        int v=vec[u][i].v;
        int w=vec[u][i].w;
        if(v==pre) continue;
        dfs(v,u);
        dp[u][]=max(dp[u][],dp[v][]-w);
        dp[u][]=max(dp[u][],dp[v][]-w);
    }
    ans=max(ans,dp[u][]+dp[u][]);
}

int main()
{
    int u,v,w;
    rush()
    {
        scanf("%d",&n);
        for(int i=;i<=n;i++)
        {
            vec[i].clear();
        }
        for(int i=;i<=n;i++)
        {
            scanf("%d",&val[i]);
        }
        for(int i=;i<n;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            vec[u].push_back(node(v,w));
            vec[v].push_back(node(u,w));
        }
        ans=;
        dfs(,-);
        printf("%d\n",ans);
    }
    return ;
}

网络流:

直接构图 费用流跑一遍

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<string.h>
#include<set>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<cmath>
typedef long long ll;
typedef unsigned long long LL;
using namespace std;
const double PI=acos(-1.0);
const double eps=0.0000000001;
const int INF=0x3f3f3f3f;
const int N=+;
int a[N];
int head[N];
int dis[N];
int pre[N];
int vis[N];
int tot;
int m,n;
struct node{
    int from,to,next,flow,cost;
}edge[N<<];
void init(){
    memset(head,-,sizeof(head));
    tot=;
}
void add(int u,int v,int c,int cost){
    edge[tot].from=u;
    edge[tot].to=v;
    edge[tot].flow=c;
    edge[tot].cost=cost;
    edge[tot].next=head[u];
    head[u]=tot++;
    edge[tot].from=v;
    edge[tot].to=u;
    edge[tot].flow=;
    edge[tot].cost=-cost;
    edge[tot].next=head[v];
    head[v]=tot++;
}
int spfa(int s,int t){
    memset(pre,-,sizeof(pre));
    memset(dis,INF,sizeof(dis));
    memset(vis,,sizeof(vis));
    queue<int>q;
    dis[s]=;
    vis[s]=;
    q.push(s);
    while(!q.empty()){
        int x=q.front();
        q.pop();
        vis[x]=;
        for(int i=head[x];i!=-;i=edge[i].next){
            int v=edge[i].to;
            if(edge[i].flow&&dis[v]>dis[x]+edge[i].cost){
                dis[v]=edge[i].cost+dis[x];
                pre[v]=i;
                if(vis[v]==){
                    vis[v]=;
                    q.push(v);
                }

            }
        }
    }
    if(pre[t]==-)return ;
    return ;
}
int MCMF(int s,int t){
    int flow=;
    int cost=;
    while(spfa(s,t)){
        int minn=INF;
        for(int i=pre[t];i!=-;i=pre[edge[i].from]){
            minn=min(minn,edge[i].flow);
        }
        for(int i=pre[t];i!=-;i=pre[edge[i].from]){
            edge[i].flow=edge[i].flow-minn;
            edge[i^].flow=edge[i^].flow+minn;
            cost=edge[i].cost+cost;
           // cout<<cost<<endl;
        }
        flow=flow+minn;
    }
    return cost;
}
int main(){
    int tt;
    scanf("%d",&tt);
    while(tt--){
        init();
        scanf("%d",&n);
        for(int i=;i<=n;i++){
            scanf("%d",&a[i]);
        }
        int s=;
        int s1=n+;
        int t=n+;
        add(s,s1,,);
        for(int i=;i<=n;i++){
            add(s1,i,,-a[i]);
        }
        for(int i=;i<=n;i++){
            add(i,t,,a[i]);
        }
        for(int i=;i<=n-;i++){
            int u,v,cost;
            scanf("%d%d%d",&u,&v,&cost);
            add(u,v,,cost);
            add(v,u,,cost);
        }
        cout<<abs(MCMF(s,t))<<endl;
    }
}