程序设计WEEK3 DFS与贪心算法

问题一：选数问题

问题描述：
Given nn positive numbers, ZJM can select exactly KK of them that sums to SS. Now ZJM wonders how many ways to get it!
Input：
The first line, an integer T<=100, indicates the number of test cases. For each case, there are two lines. The first line, three integers indicate nn, K and S. The second line, nn integers indicate the positive numbers.
Output:
For each case, an integer indicate the answer in a independent line.
simple：
input:

1
10 3 10
1 2 3 4 5 6 7 8 9 10

output:

4

问题思考：
最基本的方法是DFS暴力穷举所有的情况，这样再将每一种情况判断是否满足，伪代码如下

void BFS(int i)
{
	//将a[i]置为1表示加入队列
	a[i] = 1; BFS(i+1)；
	//将a[i]置为0表示不加入；
	a[i] = 0; BFS(i+1);
	if()
	{
	...
	//判断是否满足N个数和为S的情况
	}
}

该方法由于会走各种长于N个数的长度情况，所以不被采用，因为最坏的情况会造成只有T/((T)!-T)的可能性是满足数目为Nr情况，这样大片的无效访问会拉低速度，所以我们采用剪枝的策略将所有的一定不可能的情况去掉

void dfs(int i)
{
	//为3时进入判断是否结果等于S
	if(q.size()==N){...}
	//大于3时直接返回，不走小于三的情况
	if(q.size()>3) return;
	//加入队列
	q.push_back(i);DFS(i+1)
	//从队列中删除,不加入队列
	q.pop_back();  DFS(i+1);
}

这样获得的代码为

void bfs(int i,int sum, vector<int> q)
{
 if(q.size()==K&&sum==0)
 {
  tot++;
  return;
 }
 if(i>=n) return;
 if(q.size()>K||sum<0) return;
 bfs(i+1,sum,q);
 q.push_back(a[i]);
 bfs(i+1,sum - a[i],q);
 q.pop_back(); 
}

问题二：区间选点问题
问题描述：
数轴上有 n 个闭区间 [a_i, b_i]。取尽量少的点，使得每个区间内都至少有一个点（不同区间内含的点可以是同一个）
Input:
第一行1个整数N（N<=100）
第2~N+1行，每行两个整数a,b（a,b<=100）
Output:
一个整数，代表选点的数目
simple:
Input

2
1 5
4 6

Output

 1

Input

3
1 3
2 5
4 6

Output

2

问题思考：
贪心指标的选取：
1.选择区间开始最小
2.选择区间结束最小
3.选择区间结束最大

判断可行性：
区间最大，则会有区间没有被覆盖到。
区间开始最小，考虑区间15,24,35，该方法选出来为3个点，实际上一点就可以。
区间结束最小，则选出来之后可以覆盖最多的区间，选出来之后的点，没有办法再拆分的更少，类似于来连通图，一个点代表了一个连通图，与其他的连通图不重合
交换证明法：假设最优解为a1,a2,a3,a4…，而通过这种方法得到的结果为b1,b2,b3,b4…,假设这两种结果不相同，则必存在一个点bn是不等于an的，则假设两端区间都按照区间结束点从小到大排列，则bn由于在区间的最后端，因为排列好后后面的区间必然结束点大于当前区间，所以在最后面的为值必然覆盖到最多的点，所以该点为局部最优，同理证明其他的地方也是最优的，则我们的贪心结果就是最优的。

所以该代码为

#include<iostream>
#include<iomanip>
#include<stdio.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using namespace std;
struct Pair{
 int a;int b;
 bool operator<(const Pair& p)
 {
  if(b!=p.b) return b<p.b;
  else if(p.a!=a) return a<p.a;
  return 0;
 }
};
int main()
{
 int n;
 cin>>n;
 vector<Pair> q;
 while(n--)
 {
  Pair p;
  cin>>p.a;
  cin>>p.b;
  q.push_back(p);
 }
 sort(q.begin(),q.end());
 int c=0;
 int tail;
  int tail;
 for(int i = 0;i<q.size();i++)
 {
  if(i==0)
  {
   tail = q[0].b;
   c++;
   continue;
  }
  if(tail<=q[i].b&&tail>=q[i].a)
  {
   continue;
  }
  if(tail<=q[i].a)
  {
   tail = q[i].b;
   c++;
   continue;
  }
  
 }
 cout<<c;
}

问题三：区间覆盖问题

问题描述：
数轴上有 n (1<=n<=25000)个闭区间 [ai, bi]，选择尽量少的区间覆盖一条指定线段 [1, t]（ 1<=t<=1,000,000）。

覆盖整点，即(1,2)+(3,4)可以覆盖(1,4)。

不可能办到输出-1
输入：
第一行：N和T
第二行至N+1行: 每一行一个闭区间。
输出：
选择的区间的数目，不可能办到输出-1
样例输入：

3 10
1 7
3 6
6 10

样例输出：

2

问题分析：
贪心策略：
先将其按照左端点由小到大，右端点由大到小排列，找到从1开始的点，将最大的右端点找到，然后以该端点为最为新的起始点继续下去
证明贪心方法：左端点由小到大右端点由大到小，区间开始为开始的区间我们能选出最优的，即最大的区间来，同理我们将起始点设置为我们选出的区间的结束位置，那么就能得到下一个最优解，银为每一次都是最优的，所以结果也一定是最优的。
代码如下：

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<iomanip>
#include<vector>
using namespace std;
struct Pair
{
 int a;int b;
 
};
bool cmp(Pair p,Pair q)
 {
  return p.a<q.a;
 }
Pair s[25000];
int main()
{
 int n,t;
 cin>>n>>t;
 for(int i = 0;i<n;i++)
 {
  scanf("%d %d",&s[i].a,&s[i].b);
 }
 sort(s,s+n,cmp);
 int begin=0;//起始边界 
 int ans = 0;
 for(int i = 0;i<n&&begin<t;)
 {
 int  next= 0;
  while(i<n&&s[i].a<=begin+1)
  {
   next= max(next,s[i].b);
   i++;
  }
  //三种情况：
  //1.直接断掉，此时不会进入循环，next= 0；现在的起点值一定大于他 
  //2.没有断掉，结束时间最大的清扫工的结束事假和现在的开始值相同或者小于，此时无法继续进行 
  //3.没有断掉，结束时间大于起始时间，此时继续进行 
  if(next>begin)
  {
   begin = next;
   ans+=1;
  }
  else{
   break;
  }
 }
 if(begin<t)cout<<-1<<endl;
 else cout<<ans<<endl;
}