（贪心）（线段树） 洛谷P3078 [USACO13MAR]扑克牌型Poker Hands

一、算法分析

本人做这道题的时候，一开始以为是个区间修改的问题，然后就套上之前写的线段树模板，再加一波递归，结果只拿到了90，最后一个点还是超时了。所以后来仔细想了一下，还是要进行高效算法设计。个人的思路是对于序列依次考察，从前往后推。比如序列24123，先看2，如果只有一个2，那么结果是显然的，打两次牌即可，所以这个情况下答案是2 。然后再看24，那么打两次之后，2打完了还有4，于是就要打4次。然后再看241，显然也只需要4次。因为那个1可以在第一次就打完，同样即使是242，也只需4次。这个说明什么呢？可以这样理解，递增的部分，比如242中的24，取最大值即4，非递增部分，比如242中的42，是没有意义的，因为4后面只要跟着的是一个小于等于4的数字，那么打牌的时候就可以把它“顺便”打出去。这样本题的算法就出来了，一发直接AC。详见代码。

二、线段树模拟加递归代码（90分）

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
const int maxn=100050;
int a[maxn+2];
const int inf=999999999;
inline int read(){
  char ch=getchar();
	int ans=0,f=1;
  while(ch<'0'||ch>'9'){
	  if(ch=='-') f=-1;
		ch=getchar();
	}
  while(ch>='0'&&ch<='9'){
	  ans=ans*10+ch-'0';
		ch=getchar();
	}
  return ans*f;
}
struct node{
	int l;
	int r;
	ll v;
	ll ad;
};

node t[4*maxn+5];

void jz(int p,int l,int r){                   //建树函数 
    t[p].l=l;
		t[p].r=r;
    if(l==r){
      t[p].v=a[l];
      return;
    }
    int mid=l+r>>1;
    jz(p*2,l,mid);                            //递归建树
    jz(p*2+1,mid+1,r);                        //一定要先更新子节点再加 
    t[p].v=t[p*2].v+t[p*2+1].v;
} 

void jc(int p){
    if(t[p].ad){
      t[p*2].v+=t[p].ad*(t[p*2].r-t[p*2].l+1);
      t[p*2+1].v+=t[p].ad*(t[p*2+1].r-t[p*2+1].l+1);//和上一行相近，可以复制粘贴，spread和访问时的代码也相近，只是这个是父子间的传递，而访问返回的是同层的 
      t[p*2].ad+=t[p].ad;
      t[p*2+1].ad+=t[p].ad;
      t[p].ad=0;                             //继承父节点同时将父节点清空 
    }
}

void gx(int p,int x,int y,int z){
    if(x<=t[p].l && y>=t[p].r){
      t[p].v+=(long long)z*(t[p].r-t[p].l+1);
      t[p].ad+=z;
      return;
    }
    jc(p);                                   //如果上面的return没有走掉，那就要进行向下递归，递归前处理ad
    int mid=t[p].l+t[p].r>>1;
    if(x<=mid) gx(p*2,x,y,z);
    if(y>mid) gx(p*2+1,x,y,z);
    t[p].v=t[p*2].v+t[p*2+1].v;   
}

ll fw(int p,int x,int y){
    if(x<=t[p].l && y>=t[p].r) return t[p].v;
    jc(p);
    int mid=t[p].l+t[p].r>>1;
    ll ans=0;
    if(x<=mid) ans+=fw(p*2,x,y);
    if(y>mid) ans+=fw(p*2+1,x,y);
    return ans;
}
ll ans=0;
int n;
void dfs(int lft,int rit){
	if(lft<1 || rit>n || rit<lft) return;
	int pos=0;
	int minn=inf;
	for(int i=lft;i<=rit;i++){
		if(fw(1,i,i)==0){
			dfs(lft,i-1);
			dfs(i+1,rit);
			return;
		}
		if(fw(1,i,i)<minn){
		  minn=fw(1,i,i);
		  pos=i;
		}
	}
	ans+=minn;
	minn*=-1;
	gx(1,lft,rit,minn);
	dfs(lft,pos-1);
	dfs(pos+1,rit);
}
int main(){
  
  n=read();
  for(int i=1;i<=n;i++) a[i]=read();
  jz(1,1,n);
  dfs(1,n);
  cout<<ans;
  
	
  return 0;
}

三、高效算法（其实是体现了贪心思想）

上面我们算法分析中的算法的代码实现

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
ll n,x,maxx,ans;
int main(){
  
  cin>>n;
  for(int i=0;i<n;i++){
  	cin>>x;
  	if(x>maxx) ans+=x-maxx;
  	maxx=x;
	}
  
  cout<<ans;
  
	
  return 0;
}