[USACO GOLD] 选做

最新推荐文章于 2022-03-28 14:06:56 发布

jjikkollp

最新推荐文章于 2022-03-28 14:06:56 发布

阅读量266

点赞数

CC 4.0 BY-SA版权

分类专栏：一些题目

本文链接：https://blog.youkuaiyun.com/jjikkollp/article/details/77049690

一些题目专栏收录该内容

1 篇文章

订阅专栏

本文解析了两道经典算法题目：一是关于矩形网格中特定路径计数问题的动态规划算法；二是通过修改图中某条边权重来最大化最短路径长度的问题。文章详细介绍了算法思路与实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

[bzoj3939] 2015FEB
给定一个n*m $(n,m\leq750)$ 的矩形，每个点有不同的颜色，求从左上角到达右下角且路径满足以下条件：

由A走到B需要满足
1.B格子在A格子的严格右方(B的列号严格大于A的列号) 
2.B格子在A格子的严格下方(B的行号严格大于A的行号) 
3.B格子的标号和A格子的颜色不同

我们有一个 $O(n^4)$ 的dp：
$dp[i][j]=\sum{dp[k][p]}-\sum{dp[k][p]*(e[i][j]==e[k][p])}$
我们发现一个点的转移是可以逐行然后逆序枚举列坐标来处理的，只需要记录当前所有的值的allsum和一个sum[]表示当前颜色已经出现过的dp值之和。
于是我们可以用多个线段树来维护一下枚举到当前点时，所有已经计算过的列坐标上是当前颜色的dp和，再维护一个dp数组的二维前缀和，这样就可以更新出当前点的值，更新一下线段树的值就可以了。
核心：

rep(i,1,n){
    rpe(j,m,1){
        int sum1=sum[i-1][j-1];
        int sum2=query(root[e[i][j]],1,j-1);
        dp[i][j]=((dp[i][j]+sum1-sum2)%mod+mod)%mod;
        upd(root[e[i][j]],j,dp[i][j]);
    }
    rep(j,1,m){
      s[j]=(s[j-1]+dp[i][j])%mod,sum[i][j]=(sum[i-1][j]+s[j])%mod;
    }
}

~~但是我们不想写线段树怎么办呢~~
这道题如果写cdq的话就十分好写了。
我们按照列坐标二分，先处理左边的dp值，然后更新当前的右侧的答案，在处理右边的dp值。
核心：

inline void cdq(int l,int r){
    if(l==r)
        return;
    int mid=(l+r)>>1;
    cdq(l,mid);
    int allsum=0;
    rep(i,1,n){
        rep(j,mid+1,r){
            dp[i][j]=((dp[i][j]+allsum-sum[e[i][j]])%mod+mod)%mod;
        }
        rep(j,l,mid){
            allsum=(allsum+dp[i][j])%mod;
            sum[e[i][j]]=(sum[e[i][j]]+dp[i][j])%mod;
        }
    }
    rep(i,1,n){
        rep(j,l,mid){
            sum[e[i][j]]=0;
        }
    }
    cdq(mid+1,r);
}

时间复杂度 $O(n^2log)$

[bzoj3445]2014FEB
给定一个无向图，求一条边加倍之后最长的最短路。
题解：
直接找最短路，记录路径，暴力路径上所有的边翻倍之后求最短路

#include<bits/stdc++.h>
using namespace std;
#define rep(i,l,r) for(int i=l;i<=r;i++)
#define rpe(i,r,l) for(int i=r;i>=l;i--)
#define dyes cerr<<"yes"<<endl
const int maxn=5e5+10;
inline int read(){
    int ret=0,flag=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-')
            flag=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        ret=ret*10+ch-'0';
        ch=getchar();
    }
    return ret*flag;
}
int head[300],cnt;
struct node{
    int next,to,w;
}e[maxn];
inline void add(int u,int v,int w){
    e[cnt].to=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt++;
}
int n,m;
int x,y,z;
queue<int> q;
int vis[maxn];
int dis[maxn];
int pre[maxn];
int a[maxn];
inline void spfa(){
    memset(dis,0x3f,sizeof(head));
    vis[1]=1;
    dis[1]=0;
    q.push(1);
    while(!q.empty()){
        int cur=q.front();
        vis[cur]=0;
        q.pop();
        for(int i=head[cur];~i;i=e[i].next){
            if(dis[e[i].to]>dis[cur]+e[i].w){
                dis[e[i].to]=dis[cur]+e[i].w;
                pre[e[i].to]=cur;
                a[e[i].to]=i;
                if(!vis[e[i].to]){
                    vis[e[i].to]=1;
                    q.push(e[i].to);
                }
            }
        }
    }
}
inline void spfa2(){
    memset(dis,0x3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    vis[1]=1;
    dis[1]=0;
    while(!q.empty()) q.pop();
    q.push(1);
    while(!q.empty()){
        int cur=q.front();
        vis[cur]=0;
        q.pop();
        for(int i=head[cur];~i;i=e[i].next){
            if(dis[e[i].to]>dis[cur]+e[i].w){
                dis[e[i].to]=dis[cur]+e[i].w;
                if(!vis[e[i].to]){
                    vis[e[i].to]=1;
                    q.push(e[i].to);
                }
            }
        }
    }
}
int ans;
int main(int argc,const char * argv[]){
    memset(head,-1,sizeof(head));
    n=read();m=read();
    rep(i,1,m){
        x=read();y=read();z=read();
        add(x,y,z);
        add(y,x,z);
    }
    spfa();
    //dyes;
    //cerr<<dis[n]<<endl;
    int len=dis[n];
    int cur=n;
    //rep(i,1,n){
    //  cerr<<pre[i]<<" ";
    //}
    //cerr<<endl;
    while(cur!=1){
        e[a[cur]].w*=2;e[a[cur]^1].w*=2;
        spfa2();
        //dyes;
        ans=max(ans,dis[n]-len);
        e[a[cur]].w/=2;e[a[cur]^1].w/=2;
        cur=pre[cur];
    }
    cout<<ans<<endl;
    return 0;
}

时间复杂度： $O(nkm)$