贪心算法

要区间上的点尽可能要在另一个区间上出现过，我们就要使这个区间尽可能变长，覆盖别的区间，

1.所以我们可以把区间按右端点从小到大排序

2.然后依次枚举每一个区间，若下一个区间上的点包含在当下区间内，则直接pass，若没有则把这个区间的右端点，更新为下一个区间的右端点。

#include <iostream>
#include <algorithm>
using namespace std;
const int N=1e5+10;
struct stu{
    int l,r;
}a[N];
bool paisu(stu &a1,stu &a2){
    return a1.r<a2.r;
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)cin>>a[i].l>>a[i].r;
    sort(a,a+n,paisu);
    int res=0,ed=-2e9;
    for(int i=0;i<n;i++){
        if(a[i].l>ed){
            res++;
            ed=a[i].r;
        }
    }
    cout<<res;
    
}

合并果子

 

 这道题的结构像哈夫曼编码一样，像一个完全二叉树。

 1.这里可以直接用堆来查找最小值，然后把最小值删除

2.取每两个最小值现加，再把他们相加的和加入堆中

3.创建一个res读入所加的价值，这里要用while判断条件堆中元素是否能够合并，就是size（)>1;

而不能用empty（）

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    int n;
    cin>>n;
  priority_queue<int,vector<int>,greater<int>>a;
  for(int i=0;i<n;i++){
      int x;
      cin>>x;
      a.push(x);
  }
  int res=0;
  while(a.size()>1){
      int b=a.top();
      a.pop();
      int c=a.top();
      a.pop();
      res+=b+c;
      a.push(b+c);
  }
  cout<<res;
  
}

这道题要使等待时间最少，就要使打水时间少的人先打，这道题结果可能爆int，所以用longlong来存

 1.用数组来存入数据，再进行排序

2.叠加

#include <iostream>
#include <algorithm>
using namespace std;
const int N=1e5+10;
int a[N];
typedef long long LL;

int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)cin>>a[i];
    sort(a,a+n);
    LL res=0,t=0;
    for(int i=0;i<n;i++){
        res+=t;
        t+=a[i];
    }
    cout<<res;
    return 0;
}

 这题有个结论，先将所有点排一个序，若n为奇数，则x应该选到中位数，若n为偶数，则x应该选在中间两个数之间，也可以选中间两个数任意一个数。

证明：求数轴上任意一点到a，b之间的距离最短

 显而易见，这里应该取a和b之间或a，b的任意一点，距离为ab

因为当点在a,b之外时，距离为ab+c,c为一个常数

这样就可以类比n为4，n为5的情况

注意：n/2为什么可以代表中位数的情况。

举例：n=4,则0，1，2，3，n/2=2符合条件

n=5，则0，1，2，3，4,n/2=2符合条件

#include <iostream>
#include <algorithm>
using namespace std;
const int N=1e5+10;
int a[N];
int main(){
	int n;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i];
	}
	sort(a,a+n);
	int res=0;
	for(int i=0;i<n;i++)res+=abs(a[i]-a[n/2]);
	cout<<res;
	return 0;
}

 这题扎起来看好像时二分，其实是贪心

怎么找出贪心的关系呢，这里我们可以试着交换两头牛的位置，看一下他们交换后危险系数会怎样变化，通过变化规律得出怎样排序才能使危险系数降到最小。

比如说把wi和wi+1头牛进行交换。

交换前后：

 由于前面w1+w2+w3+w4+。。。wi-1的部分都相等，所以可以直接省去。

 这里我们把同时含有w和s的项提取出来，再移项将相同项移到一边，这里作个假设，假设左边大于右边，那么交换前的风险的最大值就要大于交换后风险的最大值，

可以看出wi-si+1>wi+1-si,而wi-si+1一定>-si+1，而-si一定<wi+1-si所以wi-si+1为最大风险值。

这样我们就可以知道排序的规律，将w+s相加小的排在前面。

步骤：1.用pair数组读入两个数，在进行排序按排序规律，pair在存两个数的时侯比较方便。

#include <iostream>
#include <algorithm>
using namespace std;
typedef pair<int,int>PII;
const int N=50010;
int n;
PII cow[N];
int main(){
	cin>>n;
	for(int i=0;i<n;i++){
		int s,w;
		cin>>s>>w;
		cow[i]={w+s,w};
	}
	sort(cow,cow+n);
	int res=-2e9,sum=0;
	for(int i=0;i<n;i++){
		int s=cow[i].first-cow[i].second,w=cow[i].second;
		res=max(res,sum-s);
		sum+=w;
				
	}
	cout<<res;
	return 0;
}