简单区间问题~贪心

简单的区间问题~

~~萌新在这里记录一下 ~~
A.不重叠的线段 51Nod - 1133
最基础的区间问题~也就是《挑战》一书中P41贪心提到的区间问题(选取最多的工作数目)
tips:题意就不说了8~ 贪心的思想,工作结束的越早(线段的右端点越小),越对后面的影响小。
要注意端点可不可以重合,每个题要求不一样~

#include<bits/stdc++.h>
using namespace std;

struct node{
	int l,r;
}book[10005];

int cmp(node n1, node n2){
	return n1.r < n2.r;
}

int n,cnt,last;

void solve(){
	scanf("%d",&n);
	for(int i = 1; i <= n; ++i)
		scanf("%d%d", &book[i].l, &book[i].r);
	sort(book + 1, book + 1 + n, cmp);
	last = book[1].r, cnt = 1;
	for(int i = 2; i <= n; ++i){
		if(book[i].l >= last)	cnt++, last = book[i].r;
	}
	printf("%d", cnt);
}

int main(){
	solve();
	return 0;
} 


下面给出另一种(麻烦一点的)做法,主要是为了B做铺垫~
思路也是贪心,左端点排序后右端点排序,然后用tmp记录,每次都排序,tmp[1]保存右端点最大的,tmp[2]保存当前的,然后判断,如果不相交,继续;如果相交,把tmp[1](右端点打,对后续影响大的点)删掉,tmp[1]更改为tmp[2]。
正确性分析:由于是从左到右扫描,当前两个相交,去掉右端点最大的能够最大的减少对后面区间的影响;如果不相交,因为区间左端点递增,之后的区间肯定不会再跟这两个里面右端点最小的相交了,因此不用再考虑这个区间。

#include<bits/stdc++.h>
using namespace std;

struct node{
	int l,r;
}book[10005],tmp[3]; 
int n,cnt;

int cmp(node n1, node n2){
	return (n1.l != n2.l) ? n1.l < n2.l : n1.r < n2.r;
}
int cmp2(node n1, node n2){
	return n1.r > n2.r;
}
bool intersect(const node& n1, const node& n2){
	if(n1.l >= n2.r || n1.r <= n2.l )		return 0;		//不相交 
	return 1;
}
void solve(){
	scanf("%d", &n);
	for(int i = 1; i <= n; ++i)
		scanf("%d%d", &book[i].l , &book[i].r);
	sort(book + 1, book + 1 + n, cmp);
	tmp[1] = book[1];
	for(int i = 2; i <= n; ++i){
		tmp[2] = book[i];
		sort(tmp + 1, tmp + 3, cmp2);
		if(intersect(tmp[1], tmp[2])){
			cnt++;
			tmp[1] = tmp[2];
		}	
	}
	printf("%d",n - cnt);
}
int main(){
	solve();
	return 0;
}

B .ZOJ-3953-Intervals【贪心】【17th浙大校赛】
tips:删掉最少的区间,使得不存在任意三个区间两两相交。
思路和上面的第二种方法类似(几乎完全一样),左端点降序后右端点降序。然后每次取出当前右端点最长的两个线段和当前线段比较,若不相交继续;相交则删除右端点最大的线段(对后续影响最大)。正确性同样。

#include<bits/stdc++.h>
using namespace std;

struct node{
	int l,r,id;
}book[50005], tmp[4];
int n,ans[50005],cnt,t;

int cmp1(node n1, node n2){
	return (n1.l != n2.l) ? n1.l < n2.l : n1.r < n2.r;
}
int cmp2(node n1, node n2){
	return n1.r > n2.r;
}
bool intersect(node &n1, node& n2){
	if(n1.l > n2.r || n1.r < n2.l )	return 0;		//不相交
	return 1; 
}

void solve(){
	scanf("%d",&n);
	cnt = 0;
	for(int i = 1; i <= n; ++i){
		scanf("%d%d", &book[i].l, &book[i].r);
		book[i].id = i;
	}
	sort(book + 1, book + 1 + n, cmp1);
	tmp[1] = book[1], tmp[2] = book[2];
	for(int i = 3; i <= n; ++i){
		tmp[3] = book[i];
		sort(tmp + 1, tmp + 4, cmp2);
		if(intersect(tmp[1], tmp[2]) && intersect(tmp[1], tmp[3]) && intersect(tmp[2], tmp[3])){
			ans[++cnt] = tmp[1].id;
			tmp[1] = tmp[3];	
		}
	}
	printf("%d\n",cnt);
	sort(ans + 1, ans + 1 + cnt);
	for(int i = 1; i <= cnt; ++i)
		printf("%d ",ans[i]);
	putchar('\n');
}
int main(){
	scanf("%d",&t);
	while(t--){
		solve();
	}
	return 0;
} 

C. (原题H) - Tokens on the Segments 19山东省赛
具体的题解看上一篇8!
19山东省赛题解

### 贪心算法解决区间调度问题 #### 示例说明 在一个典型的时间区间调度问题中,假设有一组活动,每个活动有一个开始时间和结束时间。目标是从这些活动中选择尽可能多的互不重叠的活动[^5]。 为了实现这一目标,可以采用贪心算法的思想:每次都优先选择结束时间最早的活动,并移除与其冲突的所有其他活动。这种策略能够保证在每一步都做出局部最优的选择,从而最终获得全局次优或最优解[^1]。 #### 实现步骤解析 以下是基于上述思想的具体实现方法: 1. **输入数据结构化** 输入的数据应表示为一系列区间 `[start, end]`,其中 `start` 表示活动的起始时间,`end` 表示活动的终止时间。 2. **按结束时间排序** 对所有的活动按照其结束时间从小到大进行排序。如果两个活动具有相同的结束时间,则可以根据它们的开始时间进一步排序[^4]。 3. **迭代选取活动** 初始化一个变量记录上一次选中的活动的结束时间。遍历已排序的活动列表,在每次循环中判断当前活动是否与前一选定活动存在冲突(即当前活动的开始时间小于等于上次选中活动的结束时间)。如果没有冲突,则将其加入结果集中并更新记录的结束时间为当前活动的结束时间。 #### Java代码实现 下面提供了一个完整的Java程序来展示如何利用贪心算法求解此类问题: ```java import java.util.*; public class IntervalScheduling { public static List<int[]> selectMaxNonOverlappingIntervals(List<int[]> intervals) { if (intervals == null || intervals.isEmpty()) return new ArrayList<>(); // Sort the intervals by their ending times. Collections.sort(intervals, Comparator.comparingInt(interval -> interval[1])); List<int[]> result = new ArrayList<>(); int[] lastSelectedInterval = intervals.get(0); result.add(lastSelectedInterval); for (int i = 1; i < intervals.size(); ++i){ int[] currentInterval = intervals.get(i); if(currentInterval[0] >= lastSelectedInterval[1]){ result.add(currentInterval); lastSelectedInterval = currentInterval; } } return result; } public static void main(String[] args) { List<int[]> activities = Arrays.asList( new int[]{1, 3}, new int[]{2, 4}, new int[]{3, 5}, new int[]{6, 8} ); List<int[]> selectedActivities = selectMaxNonOverlappingIntervals(activities); System.out.println("Selected Activities:"); for (int[] activity : selectedActivities) { System.out.printf("[%d, %d]%n", activity[0], activity[1]); } } } ``` 此代码实现了基本的功能需求,展示了如何通过排序和简单的逻辑操作快速筛选出符合条件的最大数量无交叉区间集合[^3]。 #### 结果分析 运行以上代码后,可以看到输出选择了哪些活动作为解决方案的一部分。这种方法不仅简单高效而且易于理解,非常适合用于实际应用场景下的初步规划阶段[^2]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值