练贪心！贪心！贪心！

最新推荐文章于 2024-09-12 23:55:58 发布
最新推荐文章于 2024-09-12 23:55:58 发布
阅读量665 收藏 1
点赞数
分类专栏： 总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heheda_is_an_OIer/article/details/49862745
版权
今天模拟赛好水的一道贪心还想了半天，所以我要练！练！练！
bzoj 1052 覆盖
用三个等大的正方形覆盖所有点，使正方形边长最小
二分边长，贪心判定：用一个最小的矩形覆盖所有点，则第一个正方形的一个顶点一定是矩形的一个顶点，第二个正方形在剩下的点中这个性质依然成立。 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>

#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 20010
using namespace std;
struct point { int x,y;} p[N];
int vis[N];
int n,A,B,C,D;
bool jd(int x,int y,int len)
{
	//printf("	jd: %d %d %d\n",x,y,len);
	int A=inf,B=-inf,C=-inf,D=inf;
	for (int i=1;i<=n;i++)
	{
		if (vis[i]==1) continue;
		if (x<=p[i].x&&p[i].x<=x+len&&y<=p[i].y&&p[i].y<=y+len) vis[i]=2;
		else
		{
			A=min(A,p[i].x); B=max(B,p[i].x);
			C=max(C,p[i].y); D=min(D,p[i].y);
		}
	}
	//for (int i=1;i<=n;i++) printf("%d ",vis[i]); printf("\n");
	//printf("		abcd: %d %d %d %d\n",A,B,C,D);
	if (A==inf||(B-A<=len&&C-D<=len)) return 1; else return 0;
}

bool solve(int x,int y,int len)
{
	//printf("solve: %d %d %d\n",x,y,len);
	memset(vis,0,sizeof(vis));
	int A=inf,B=-inf,C=-inf,D=inf;
	for (int i=1;i<=n;i++)
	{
		if (x<=p[i].x&&p[i].x<=x+len&&y<=p[i].y&&p[i].y<=y+len) vis[i]=1;
		else
		{
			A=min(A,p[i].x); B=max(B,p[i].x);
			C=max(C,p[i].y); D=min(D,p[i].y);
		}
	}
	if (A==inf) return 1;
	if (jd(A,D,len)) return 1;
	if (jd(A,C-len,len)) return 1;
	if (jd(B-len,D,len)) return 1;
	if (jd(B-len,C-len,len)) return 1;
	return 0;
}
	
bool ok(int len)
{
	if (solve(A,D,len)) return 1;
	if (solve(A,C-len,len)) return 1;
	if (solve(B-len,D,len)) return 1;
	if (solve(B-len,C-len,len)) return 1;
	return 0;
}
int main()
{
	scanf("%d",&n);
	A=inf; B=-inf; C=-inf; D=inf;
	for (int i=1;i<=n;i++)
	{
		scanf("%d%d",&p[i].x,&p[i].y);
		A=min(A,p[i].x); B=max(B,p[i].x);
		C=max(C,p[i].y); D=min(D,p[i].y);
	}
	int l=1,r=inf;
	while (l!=r)
	{
		int mid=(l+r)>>1;
		if (ok(mid)) r=mid; else l=mid+1;
	}
	printf("%d\n",l);
	return 0;
}
bzoj 2811 覆盖
一个01序列，要求有的区间必须全是0，有的区间必须有1，询问哪些点一定是1.
首先将必须是0的区间删掉，如果这时只剩k个点，直接输出。
通过单调栈留下一些互不包含的区间。
要使放的1最少，一定是依次枚举每个区间，如果当前区间内没有1，就在区间的右端点放上1.然后明显其它的点都是可放可不放的。
用f[i],g[i]分别表示如此做从左往右/从右往左前i个区间放了多少个1.
枚举每一个右端点放1的区间，如果将这个1左移一位之后需要的点数大于k，那么这个点一定要放1，否则不就可以放在左移一位的位置上了吗？
那么如何判断是否大于k？
在i之前的最右面的不覆盖i-1的区间t1的f值加上在i之后最左面的不覆盖i-1的区间t2的g值，再加上i-1的位置放上的1，这样所有的区间都满足要求。也就是如果f[t1]+g[t2]+1>k，就输出第i个区间的右端点。
注意寻找包含区间是最左面的q[i].r>=pos 和最右边的 q[i].l<=pos。 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>

#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 100010
using namespace std;
struct data { int l,r,c;} q[N],a[N];
int c[N],is[N],ql[N],qr[N],f[N],g[N];
int n;
bool cmp(data a,data b) { return a.l==b.l?a.r>b.r:a.l<b.l;}
void add(int x,int d)
{
	for (;x<=n;x+=x&(-x)) c[x]+=d;
}
int qsum(int x)
{
	int ans=0;
	for (;x;x-=x&(-x)) ans+=c[x];
	return ans;
}
int main()
{
	int K,m;
	scanf("%d%d%d",&n,&K,&m);
	for (int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&a[i].l,&a[i].r,&a[i].c);
		if (a[i].c==0)
		{
			add(a[i].l,1); add(a[i].r+1,-1);
		}
	}
	int w=0;
	for (int i=1;i<=n;i++)
	{
	  if (qsum(i)==0)
	  {
	  	w++; is[w]=i; ql[i]=w; qr[i]=w;
	  }
	}
	if (w==K) { for (int i=1;i<=K;i++) printf("%d\n",is[i]); return 0;}
	ql[n+1]=inf; for (int i=n;i;i--) if (!ql[i]) ql[i]=ql[i+1];
	for (int i=1;i<=n;i++) if (!qr[i]) qr[i]=qr[i-1];
	//for (int i=1;i<=n;i++) printf("%d %d  ",ql[i],qr[i]); printf("\n");
	int top=0;
	for (int i=1;i<=m;i++) { a[i].l=ql[a[i].l]; a[i].r=qr[a[i].r];} 
	//for (int i=1;i<=m;i++) printf("%d %d %d\n",a[i].l,a[i].r,a[i].c); printf("\n");
	sort(a+1,a+m+1,cmp);
	for (int i=1;i<=m;i++)
	{
		if (a[i].c)
		{
			if (a[i].l>a[i].r) continue;
			while (top&&q[top].l<=a[i].l&&a[i].r<=q[top].r) top--;
			q[++top]=a[i];
		}
	}
	//for (int i=1;i<=top;i++) printf("%d %d\n",q[i].l,q[i].r);
	//q[top+1].l=q[top+1].r=inf;
	int mn=0,mx=inf;
	for (int i=1;i<=top;i++)
	{
		if (mn<q[i].l) { mn=q[i].r; f[i]=f[i-1]+1;}
		  else f[i]=f[i-1];
	}
	for (int i=top;i;i--)
	{
		if (mx>q[i].r) { mx=q[i].l; g[i]=g[i+1]+1;}
		  else g[i]=g[i+1];
	}
	//for (int i=1;i<=top;i++) printf("%d ",f[i]); printf("\n");
	//for (int i=1;i<=top;i++) printf("%d ",g[i]); printf("\n");
	bool hv=0;
	for (int i=1;i<=top;i++)
	{
		if (q[i].l==q[i].r)
		{
			printf("%d\n",is[q[i].l]);
			hv=1;
			continue;
		}
		if (f[i]==f[i-1]) continue;
		else
		{
			int pos=q[i].r-1;
			int l=0,r=top+1;
			while (l!=r)
			{
				int mid=(l+r+1)>>1;
				if (q[mid].r<pos) l=mid; else r=mid-1;
			}
			int t1=l;
			l=t1; r=top+1;
			while (l!=r)
			{
				int mid=(l+r)>>1;
				if (q[mid].l>pos) r=mid; else l=mid+1;
			}
			int t2=l;
			if (f[t1]+g[t2]+1>K)
			{
				printf("%d\n",is[q[i].r]);
				hv=1;
			}
		}
	}
	if (!hv) printf("-1\n");
	return 0;
}
bzoj 1367 sequence
练贪心！贪心！贪心！ - zc - zc的博客
首先对于递增序列，a[i]减去i，然后就变成不下降序列。这样z数组就是几段单调递增的连续的数，就像1122234455这样。然后如果第i段数的中位数小于第i-1段数，那么就合并这两个区间，然后这个区间的答案变成这个区间的中位数。这个操作可以用可并堆维护。 因为第i个区间的中位数单调不降，所以只需要维护最大的size/2个数 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>

#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 1000010
using namespace std;
int a[N],v[N],lx[N],rx[N],sz[N],dis[N],root[N],L[N],R[N];
struct left_tree
{
	int top(int x)
	{
		return v[x];
	}
	int merge(int x,int y)
	{
		if (!x) return y;
		if (!y) return x;
		if (v[x]<v[y]) swap(x,y);
		rx[x]=merge(rx[x],y);
		sz[x]=sz[lx[x]]+sz[rx[x]]+1;
		if (dis[rx[x]]>dis[lx[x]]) swap(lx[x],rx[x]);
		dis[x]=dis[rx[x]]+1;
		return x;
	}
} heap;

int main()
{
	int n;
	scanf("%d",&n);
	for (int i=1;i<=n;i++) { scanf("%d",&a[i]); a[i]-=i; }
	int top=0;
	for (int i=1;i<=n;i++)
	{
		sz[i]=dis[i]=1; lx[i]=rx[i]=0; v[i]=a[i];
		root[++top]=i; L[top]=R[top]=i;
		while (top>1&&heap.top(root[top-1])>heap.top(root[top]))
		{
			top--;
			root[top]=heap.merge(root[top],root[top+1]);
			R[top]=R[top+1];
			int tot=R[top]-L[top]+1;
			while (sz[root[top]]*2>tot+1) root[top]=heap.merge(lx[root[top]],rx[root[top]]);
		}
		//for (int j=1;j<=top;j++) printf("L: %d  R: %d mid: %d\n",L[j],R[j],heap.top(root[j])); printf("\n");
	}
	ll ans=0;
	for (int i=1;i<=top;i++)
	{
		int mid=heap.top(root[i]); //printf("\nL:%d R:%d mid: %d\n",L[i],R[i],mid);
		for (int j=L[i];j<=R[i];j++) ans+=abs(a[j]-mid); //printf("%d %d   ",a[j],mid);
	}//printf("\n");
	printf("%lld\n",ans);
	return 0;
}
bzoj 2288 礼物
从一个序列中选出至少m个区间，使他们的和最大
表示看到这道题的第一反应是那道被讲了好多遍的用线段树维护增广路
首先将连续的正数合并，连续的负数合并，答案等于所有正数的和。
维护一个堆，每次找出绝对值最小的区间，答案减去这个绝对值，然后将这个区间，它左面的区间，它右面的区间合并。这样子，堆中的元素就是选与不选交错，正数与负数交错（因为合并前两边数的绝对值大于这个数）。
选择一个负数，相当于选上这段区间，选择一个正数，相当于不选这个区间，这都能使区间数减一。
考虑边界，第一个和最后一个区间出堆之后，如果是正数，就去掉这个区间，答案减去。如果是负数，不但不会减少区间数，还会使答案变小，所以直接忽略
删除任意一个数，不想手写堆，写了set
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 100010
using namespace std;
int a[N],q[N],pre[N],ne[N];
struct data { int sm,pos,ab; };
struct cmp
{
bool operator () (data a,data b)
{
return a.ab==b.ab? a.pos<b.pos:a.ab<b.ab;
}
};
set<data,cmp> st;
int main()
{
int n,m;
scanf("%d%d",&n,&m);
int w=0;
for (int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
if (a[i]==0) { i--; n--; continue; }
if (a[i]*a[i-1]>0) q[w]+=a[i];
else q[++w]=a[i];
}
n=w; int ans=0,tot=0;
memset(a,0,sizeof(a));
for (int i=1;i<=n;i++)
{
a[i]=q[i];
if (a[i]>0) { ans+=a[i]; tot++; }
pre[i]=i-1; ne[i]=i+1;
data x=(data) { a[i],i,abs(a[i])}; st.insert(x); //printf("insert: %d\n",x.ab);
}
//for (set<data,cmp>::iterator i=st.begin();i!=st.end();i++) printf("%d ",(*i).ab); printf("\n");
if (tot<=m)
{
printf("%d\n",ans);
return 0;
}
while (tot>m)
{
data x=*st.begin();
int pos=x.pos,sm=x.sm; //printf("erase: %d %d\n",pos,sm);
int L=pre[pos],R=ne[pos];
if (L<1)
{
pre[R]=pre[pos];
if (sm>0) { tot--; ans-=x.ab; st.erase(x); }
else { st.erase(x); }
}
else if (R>n)
{
ne[L]=ne[pos];
if (sm>0) { tot--; ans-=x.ab; st.erase(x); }
else { st.erase(x); }
}
else
{
ans-=x.ab;
a[pos]=a[L]+a[R]+a[pos];
st.erase(x);
data y=(data) {a[L],L,abs(a[L])}; st.erase(y);
y=(data) {a[R],R,abs(a[R])}; st.erase(y);
x.sm=a[pos]; x.ab=abs(a[pos]); st.insert(x);
pre[pos]=pre[L]; ne[pre[L]]=pos;
ne[pos]=ne[R]; pre[ne[R]]=pos;
tot--;
}
}
printf("%d\n",ans);
return 0;
}
bzoj 4198 荷马史诗
这是一道裸的k叉哈夫曼树，每次找到权值最小的k个数合并成一个新节点，答案加上这些权值和。
要求深度最小，只需要让深度最小的先出堆。
然后将点数补成(k-1)*d+1 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 100500
using namespace std;
struct data { ll dt; int dep; } a[N];
struct cmp
{
	bool operator () (data a,data b) { return a.dt==b.dt?a.dep>b.dep:a.dt>b.dt;}
};
priority_queue<data,vector<data>,cmp> q;
int main()
{
	int n,k; 
	scanf("%d%d",&n,&k);
	for (int i=1;i<=n;i++) { scanf("%lld",&a[i].dt); a[i].dep=1;} 
	while (k!=2&&(n%(k-1))!=1) { n++; a[n].dep=a[n].dt=0; }
	for (int i=1;i<=n;i++) q.push(a[i]);
	ll ans=0;
	while (q.size()!=1)
	{
		ll sum=0; int mxdep=0;
		data x;
		for (int i=1;i<=k;i++)
		{
			x=q.top(); q.pop(); //printf("pop: %lld %d\n",x.dt,x.dep);
			sum+=x.dt; mxdep=max(mxdep,x.dep);
		}
		x.dt=sum; x.dep=mxdep+1; ans+=sum;
		q.push(x);
	}
	printf("%lld\n%d\n",ans,(q.top()).dep-1);
	return 0;
}

heheda_is_an_OIer
关注
专栏目录
贪心算法(贪婪算法)
TuttuYYDS的博客
05-07 9万+
贪心算法(贪婪算法)
C语言：贪心算法
weixin_53386343的博客
06-07 3074
因此，在应用贪心算法时，需要仔细分析问题的特点，确保贪心选择的有效性。请注意，示例中的最大价值即为背包能装载的物品的最大价值。构建贪心选择：对于给定的问题，通过定义一种选择方式，在每个阶段都做出一个贪心选择，即选择当前状态下的局部最优解。确定问题的最优子结构：贪心算法通常应用于具有最优子结构性质的问题，即问题的最优解可以通过一系列局部最优解得到。验证贪心选择的可行性：验证所做的贪心选择是否符合问题的约束条件，确保选择是可行的。更新问题的状态：根据所做的贪心选择，更新问题的状态，进入下一个阶段。
用贪心算法解决背包问题
2301_76572283的博客
05-22 2042
设有背包问题时实例n=7，m=15，（w0，w1，...，w6）=（2，3，5，7，1，4，1），物品装入背包的收益为：（p0，p1，...，p6）=（10，5，15，7，6，18，13）。先选入1号物品，再选入2号物品，但由于背包的容量剩余20-15=5，因此2号物品装入1/2，0号物品不装入，这样得到的解为（x0，x1，x2）=（0，1，1/2），它的总收益为31.5，总收益最大。贪心算法只是一种算法，它是基于贪心策略来编写的算法，贪心算法可以看作是贪心策略的具象化，算法是具体的，策略是模糊的。
Python算法L5：贪心算法
theoxiong的博客
09-06 1380
Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1. **零钱兑换问题**2. **区间调度问题**3. **背包问题**贪心算法的优缺点结语贪心算法（Greedy Algorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全局最优解，但在很多实际问题中，它能够高效地找到一个近似解。
详解贪心算法
最新发布
Weiki的博客
09-12 1287
算法：贪心算法
贪心算法讲解
学代码的咸鱼的博客
04-30 4176
一些贪心算法的练习题！
贪心算法详解
qq_46664080的博客
02-13 3099
本文主要讲述了 贪心算法思想、畜栏保留问题、区间相交问题、哈夫曼树、哈夫曼树加密等
【贪心算法】经典案例分析
热门推荐
恭仔的博客
09-26 2万+
贪心算法在每一步选择中都采取当前状态下最优的选择，以期望达到全局最优解
动态规划和贪心算法
dzy521的博客
04-02 9765
动态规划问题的第二个性质是子问题空间必须足够“小”，也就是说，问题的递归算法会求解相同的子问题，而不是一直生成新的子问题（分治法求解的问题在每一步递归都生成全新的子问题），由于子问题的求解依赖于更小的子问题的求解，我们将子问题的规模按大小排序，按由小至大的顺序进行求解，这样在求解某一个子问题时会依赖于上一个求解的子问题。两个问题都用到了子问题，而最长简单子路径的子问题是相关的，而最短路径的子问题是无关的，这里无关是指：同一个原问题的一个子问题不影响另一个子问题的解。
贪心算法：基础入门篇
Krisit的博客
08-11 2216
贪心算法所作的选择来源于以往的选择，并非将来的选择。贪心算法相对于其他算法有一定的速度优势，在一题可以多解的情况下，可以优先选择贪心算法。
贪心算法、分治算法和动态规划的区别 贪心算法和动态规划.pdf
04-08
贪心算法、分治算法和动态规划的区别 贪心算法、分治算法和动态规划是三种常用的算法设计策略，每种算法都有其特点和应用场景。下面我们将对这三种算法进行详细的比较和分析。 分治算法 分治算法是一种将原问题...
RogerPoirier.github.io:我的贪心网站！
05-15
【标题】"RogerPoirier.github.io:我的贪心网站！"揭示了这是一份与个人网站相关的项目，由GitHub用户RogerPoirier创建。这个网站可能是他的个人作品集、博客或者是用来展示技术能力的平台。GitHub上的项目通常用于...
贪心算法1
08-03
贪心算法是一种优化策略，它在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是全局最好或最优。贪心算法的特点是不考虑问题的整体最优解，而是每一步都追求局部最优解，希望这些...
贪心算法和动态规划以及分治法的区别？ (1) 贪心算法和动态规划.pdf
04-08
贪心算法、动态规划和分治法的区别 贪心算法是局部最优解的算法，它通过从上往下，从顶部一步一步最优，得到最后的结果。贪心算法顾名思义，就是做出在当前看来是最好的结果，它不从整体上加以考虑，也就是局部最优...
实验2装箱问题-贪心算法
05-23
实验2装箱问题-贪心算法 在本实验中，我们将学习贪心算法的设计和实现，以解决装箱问题。贪心算法是一种常用的近似算法，通过选择当前最优解来逐步构建解决方案。 问题描述 装箱问题是计算机科学中的一类经典问题...
CTSC&&APIO2016 旅游记&&被坑记
heheda_is_an_OIer的博客
05-10 3124
在帝都将近十天，回家之际，有一丝急迫，也有一丝眷恋。 5.1 CTSC day0         坐前一天晚上的火车，很早就到达了北京，倒了3班地铁+一班公交到达了目的地，被yts大爷领着绕了一个大圈才到宾馆，累成狗。         宾馆很高级，房间里面有70元一瓶的水，冰箱里还有各种饮料（当然是喝不起的啦），床软的可怕。睡了1个小时，人还是虚的，背了一点板子。         中午被叫
蒟蒻的noip2015滚粗记
heheda_is_an_OIer的博客
11-16 2314
oi就是一场实力与运气的博弈——题记        也不知道这会不会是自己的最后一年noip，也不知道2016夏绵阳见是什么样子。但是，第三年的noip，还是值得回味的。 Day 0        又是一个阴雨连绵日，和往常不一样的是我弃掉了周五上午的课，回家学(tui)习(fei)。花了一个小时交上了屯题，在学校群里装了装逼。喝了一大碗羊汤，就出发了。        在车上，我们一对一对
heheda练数据结构
heheda_is_an_OIer的博客
11-20 2290
联赛结束，自己的码力已经下降了不知多少个档次，再加上最近空闲时间比较多，我就开启了这个可以说最费时间的专题。 //话说我未完成的数论专题还会继续的。 最近看了以下知识点： 线段树套线段树 线段树套平衡树 准备学习： 替罪羊树 块状链表 复习： 树链剖分 树状数组套线段树 一些高级的线段树 可持久化tire 可并堆 bzoj 2957 楼房重建 给定第一象限的n
SDOI2016r1游记
heheda_is_an_OIer的博客
04-12 1831
做梦一般，SDOIR1就过去了，成绩不错，但总有一些小的细节不是太如意。 Day0 早上10点的火车，在车上和同学聊了一些奇奇怪怪的题，就到了济南，然后报道。感觉自己整个人都hai起来了。晚上写了一道题，背背板子，就睡觉了。 Day1 抽签，发现我们学校只有我,Oxer,davidxu在第二考场，但是感觉外校的神犇好多呀。 进入考场，敲完头文件、对拍之后就不知道干什么了，干坐了10分钟，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值