暑假集训日记——7.13（单调栈/单调队列+codeforce）

最新推荐文章于 2022-07-04 16:40:54 发布

THE END GAME

最新推荐文章于 2022-07-04 16:40:54 发布

阅读量980

点赞数 1

分类专栏：暑假集训 Codeforces 网络流

本文链接：https://blog.csdn.net/weixin_43870114/article/details/95764309

版权

Codeforces 同时被 3 个专栏收录

49 篇文章 1 订阅

订阅专栏

暑假集训

36 篇文章 0 订阅

订阅专栏

网络流

2 篇文章 0 订阅

订阅专栏

C. Tokitsukaze and Discard Items
题解：模拟
环的思想：按照题意模拟即可…可惜B题就做懵了

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX=1e5+10;
ll p[MAX];
int main()
{
	ll n,m,k;
	scanf("%lld%lld%lld",&n,&m,&k);
	for(int i=1;i<=m;i++) scanf("%lld",&p[i]);
	int ans=0;
	int sum=0;
	int now=1;
	while(now<=m)
	{
		ll r=((p[now]-sum-1)/k+1)*k;
	//	cout<<"r:"<<r<<endl;
		while(now<=m&&p[now]-sum<=r)
		{
			sum++;
			now++;
		}
		ans++;///操作数加一
	}
	printf("%d\n",ans);
	return 0;
}

单调栈&单调队列入门

A - Largest Rectangle in a Histogram
题意：
给出一些连续的长度为1的长方形。问所能构成的矩形的最大面积是多少？
题解：
基本上是裸题了，两边各一次单调栈即可求

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<functional>
#include<set>
#include<map>
#include<stack>
#include<iterator>
#include<queue>
#include<vector>
#include<string>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef long double ld;
#define mp make_pair

const int N=1e6+10;
const long long INF=1e18;
const double eps=0.0000001;
const ll mod=1e9+7;
ll n,m,x,y;
ll a[N];
ll b[N],height[N];

struct Node
{
    ll height,id;
};

int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    stack<Node> stacks;
    while(~scanf("%lld",&n))//不要混用
    {
        if(n==0)
            break;
        ll ans=0;
        Node temp;
        while(!stacks.empty()) stacks.pop();
        temp.height=-1,temp.id=0;//注意初始化
        stacks.push(temp);
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        for(int i=1;i<=n;i++){
            scanf("%lld",&temp.height);
            height[i]=temp.height;
            temp.id=i;
         
            while(!stacks.empty()&&stacks.top().height>=temp.height){
                stacks.pop();
            }
                a[i]=stacks.top().id;
            stacks.push(temp);

        }//cout<<1<<endl;
        while(!stacks.empty()) stacks.pop();
        temp.height=-1,temp.id=n+1;
        stacks.push(temp);
        for(int i=n;i>=1;i--){
            
            temp.id=i;
            temp.height=height[i];
            while(!stacks.empty()&&stacks.top().height>=temp.height){
                stacks.pop();
            }
                b[i]=stacks.top().id;
            stacks.push(temp);
        }
       
        for(int i=1;i<=n;i++)
        {
            ans=max(ans,(b[i]-a[i]-1)*height[i]);
        }

        cout<<ans<<endl;
    }

}

B - Sliding Window
题解：板子题

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<functional>
#include<set>
#include<map>
#include<stack>
#include<iterator>
#include<queue>
#include<vector>
#include<string>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef long double ld;
#define mp make_pair

const int N=1e6+10;
const long long INF=1e18;
const double eps=0.0000001;
const ll mod=1e9+7;
int n,m,x,y;

struct node
{
    int x,y;
}v[1010000]; //x表示值，y表示位置 可以理解为下标
int a[1010000],mx[1010000],mn[1010000];

void getmin()
{
    int i,head=1,tail=0;// 默认起始位置为1 因为插入是v[++tail]故初始化为0
    for(i=1;i<m;i++)//初始化
    {
        while(head<=tail && v[tail].x>=a[i]) tail--;//保证单调性
        v[++tail].x=a[i],v[tail].y=i;
                // 根据题目 前m-1个先直接进入队列
    }
    for(;i<=n;i++)
    {
        while(head<=tail && v[tail].x>=a[i]) tail--;
        v[++tail].x=a[i],v[tail].y=i;
        while(v[head].y<i-m+1) head++;
        mn[i-m+1]=v[head].x;
               // 道理同上，当然了 要把已经超出范围的从head开始排出
               //  然后每个队首则是目前m个数的最小值
    }
}
void getmax() //最大值同最小值的道理，只不过是维护的是递减队列
{
    int i,head=1,tail=0;
    for(i=1;i<m;i++)
    {
        while(head<=tail && v[tail].x<=a[i]) tail--;
        v[++tail].x=a[i],v[tail].y=i;
    }
    for(;i<=n;i++)
    {
        while(head<=tail && v[tail].x<=a[i]) tail--;
        v[++tail].x=a[i],v[tail].y=i;
        while(v[head].y<i-m+1) head++;
        mx[i-m+1]=v[head].x;
    }
}


int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
      int i,j;
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++)scanf("%d",&a[i]);
    getmin();
    getmax();
    for(i=1;i<=n-m+1;i++)
    {
        if(i==1)printf("%d",mn[i]);
        else printf(" %d",mn[i]);
    }
    printf("\n");
    for(i=1;i<=n-m+1;i++)
    {
        if(i==1)printf("%d",mx[i]);
        else printf(" %d",mx[i]);
    }
    printf("\n");
    return 0;


}

单调队列优化dp详解
 C - Trade
题解：dp+单调队列

动态规划： $d p [i] [j]$ 表示第i天有j个股票能赚多少钱。
那么可以分三种情况:
1)什么都不做 $d p [i] [j] = m a x (d p [i] [j], d p [i - 1] [j]);$
2)买了股票 $d p [i] [j] = m a x (d p [i] [j], d p [i - W - 1] [k] - (j - k) * A P [i]);$
3)卖了股票 $dp[i][j] = max(dp[i][j],dp[i-W-1][k] + (k - j) * BP[i]); $

按照朴素的做法枚举天数，股票数j，k复杂度为O(n ^ 3);
将买股票的状态方程转化一下成
$d p [i] [j] = m a x (d p [i - W - 1] [k] + k * A P [i]) - j * A P [i];$
令 $f [i - W - 1] = d p [i - W - 1] [k] + k * A P [i],$
那么 $d p [i] [j] = m a x (f [i - W - 1]) - j * A P [i]$ ;对于 $f [i - W - 1]$ 可以用单调队列来求。
这样复杂度就成了n ^ 2。买股票的也类似。

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;

const int MAXN=2010;
const int INF=0x3f3f3f3f;

struct node
{
    int x,y;
}v[1010000]; //x表示值，y表示位置 可以理解为下标

int ap[MAXN],bp[MAXN],as[MAXN],bs[MAXN];
int dp[MAXN][MAXN];

///dp[i][j] = max(f[i-W-1]) - j * AP[i];

int main()
{
    int t,n,p,w;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d%d",&n,&p,&w);
        for(int i=1;i<=n;i++) scanf("%d%d%d%d",&ap[i],&bp[i],&as[i],&bs[i]);
        for(int i=0;i<=n;i++)
            for(int j=0;j<=p;j++) dp[i][j]=-INF;
        dp[0][0]=0;
        for(int i=1;i<=n;i++)
        {
            ///如果不作交易的状态
            for(int j=0;j<=p;j++) dp[i][j]=max(dp[i][j],dp[i-1][j]);
            if(i-w-1<=0)///当处于交易的第一阶段时只能买股票
            {
                for(int j=0;j<=as[i];j++) dp[i][j]=max(dp[i][j],-ap[i]*j);
            }
            ///进行交易
            else
            {
                ///买
                int head=1,tail=0;
                for(int j=0;j<=p;j++)///无固定区间的单调队列
                {
                    while(head<=tail && v[tail].x<=dp[i-w-1][j]+j*ap[i]) tail--;
                    v[++tail].x=dp[i-w-1][j]+j*ap[i],v[tail].y=j;
                    while(head<=tail&&v[head].y+as[i]<j) head++;///控制数量
                    dp[i][j]=max(dp[i][j],v[head].x-j*ap[i]);    ///动态转移
                }
                ///卖
                 head=1,tail=0;
                for(int j=p;j>=0;j--)///无固定区间的单调队列
                {
                    while(head<=tail && v[tail].x<=dp[i-w-1][j]+j*bp[i]) tail--;
                    v[++tail].x=dp[i-w-1][j]+j*bp[i],v[tail].y=j;
                    while(head<=tail&&v[head].y-bs[i]>j) head++;///控制数量
                    dp[i][j]=max(dp[i][j],v[head].x-j*bp[i]);    ///动态转移
                }
            }
        }
        int ans=0;
        for(int i=0;i<=p;i++) ans=max(ans,dp[n][i]);
        printf("%d\n",ans);
    }
}

E - Drainage Ditches
题解：（求最大流问题）
注意重边的处理！！！

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<functional>
#include<set>
#include<map>
#include<stack>
#include<iterator>
#include<queue>
#include<vector>
#include<string>
using namespace std;
const int N=305;
const int inf=0x3f3f3f3f;

struct Edge
{
    int from,to,cap,flow;//顶点-顶点,容量，流量
    Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f) {}
};

vector <Edge> edges;
vector <int > G[N];
int d[N],cur[N],num[N][N];
int soure[N][N];
int n,m,S,T,a,b,C;
bool vis[N],flag;

void init()
{
    for(int i=1; i<=n; i++)
    {
        G[i].clear(),edges.clear();
    }
}

void add_edge(int from,int to,int cap)
{
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));
    C=edges.size();
    G[from].push_back(C-2);
    G[to].push_back(C-1);
}

bool bfs(int s,int t)
{
    memset(vis,false,sizeof(vis));
    queue <int>Q;
    d[s]=0;
    Q.push(s);
    vis[s]=true;
    while(!Q.empty())
    {
        int q=Q.front();
        Q.pop();
        for(int i=0; i<G[q].size(); i++)
        {
            Edge &e=edges[G[q][i]];
            if(!vis[e.to]&&e.cap>e.flow)
            {
                d[e.to]=d[q]+1;
                Q.push(e.to);
                vis[e.to]=true;
            }
        }
    }
    return vis[T];
}

int dfs(int s,int k)
{
    if(s==T||k==0) return k;
    int f,flow=0;
    for(int &i=cur[s]; i<G[s].size(); i++)
    {
        Edge &e=edges[G[s][i]];
        if(d[e.to]==d[s]+1&&(f=dfs(e.to,min(k,e.cap-e.flow)))>0)
        {
            e.flow+=f;
            edges[G[s][i]^1].flow-=f;
            flow+=f;
            k-=f;
            if(k==0) break;
        }
    }
    return flow;
}

int max_flow(int s,int t)
{
    int flow=0;
    while(bfs(s,t))
    {
        memset(cur,0,sizeof(cur));
        flow+=dfs(s,inf);
    }
    return flow;
}


int main()
{
    int x,y,z;
    while(~scanf("%d%d",&m,&n))
    {
        init();
        memset(soure,0,sizeof(soure));
        S=1,T=n;
        int sum=0,cnts=0;
        int u, v, w;
        for(int i = 0; i < m; i++){
            scanf("%d%d%d", &u, &v, &w);
            soure[u][v]+=w;///注意重边的处理！！！
        }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(soure[i][j])
                    add_edge(i, j, soure[i][j]);
        int ans=max_flow(S,T);
        cout<<ans<<endl;
    }
}

THE END GAME

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
暑假集训日记——7.13（单调栈/单调队列+codeforce）

C. Tokitsukaze and Discard Items按照题意模拟即可…可惜B题就做懵了#include <bits/stdc++.h>using namespace std;typedef long long ll;const int MAX=1e5+10;ll p[MAX];int main(){ ll n,m,k; scanf("%lld%lld%l...
复制链接

扫一扫

专栏目录