双周赛题解

区间选点：（贪心）

fr Acwing 905

把区间右端按照从小到大排序，其中第一个右端可以包含后面的解，到包含不了的时候，舍去前面素有ans++,同时更新这个包含不了的为第一个右端

贪心是可以试的，区间问题想到了端点排序，尝试右端点排序并用贪心解出来，试几个数，可以了的话，就进行证明

贪心只是当前最好的情况就像一个单峰函数，我们永远往上走才能最终走到那个顶峰

而多峰函数，当我们将要到达的那个峰可能不是最高峰的时候，贪心是没有道理的

证明这样的贪心是可以的：

ans=最优解 cnt=合法解

1 ans>=cnt：这样的贪心一定可以保证所有的段中包含至少一个点

2 ans<=cnt：间断的线段必须各一个点 剩下的不单独有点的最好，而这个贪心方法就这样

得证 ans=cnt

所以这样的贪心就是最优解：

#include <iostream>
#include <algorithm>
using namespace std;

const int N=1e5+10;
int n;

struct range{
    int l,r;
    bool operator< (const range &W)const 
    {
        return r<W.r;
    }
}range[N];

int main(){
    scanf("%d",&n);

    for(int i=1;i<=n;i++){
        int l,r;
        scanf("%d%d",&l,&r);
        range[i]={l,r};
    }
    sort(range+1,range+n+1);
    int res=0, ed=-2e9;
    for(int i=1;i<=n;i++){
        if(range[i].l>ed){
            res++;
            ed=range[i].r;
        }
    }       
    cout<<res;
    return 0;
} 

作者：我ai吹泡泡
链接：https://www.acwing.com/activity/content/code/content/7298694/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

添加括号：（CGD）

能不能的问题我们最好在现状基础上考虑最容易能的情况，因为只要能，这个最容易能的情况就最好考虑，如果不能，这个最容易能的情况，也一定不能；并且最容易能的都不能，那就彻底不能了

这道题的第一个数一定是分子，第二个数一定是分母，能成为整数那就是分子除以分母能出的开；

怎么最好能出的开呢，那就是分子越少越好同时分母越多越好，分子分母的数量差越多越好。

那就把底下的全都翻上去好了，也就a1/a2/(a3/...（/an）)

那也就是说，a1a3...an除以a2是除得开的，大数除小数了属于是，用高精度数组模拟大数，或者不把a1a3...an换成整体，而是把a1 a3 ... an拆开看成一个一个数，数拆成因子，看a2有没有这样的因子

每一个挨个给a2求最大公因数比较节省时间

#include <iostream>
#define maxn 200010
using namespace std;

int m,n;
int a[maxn];

int gcd(int x, int y){
	return y? gcd(y,x%y):x;
}

int main(){
	cin>>m;
	while(m--){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	} 
	int s=a[2];
	s/=gcd(a[1],a[2]);
	for(int i=3;i<=n;i++){
		s/=gcd(a[i],a[2]);
		if(s==1) break;
	}
	if(s!=1) cout<<"No";
	else cout<<"Yes";
	cout<<endl;
}
	return 0;
} 

因为这里的两个根之间不会超过1 所以可以以1位区间二分 临界条件是l-r<=eps

i从-100到100遍历 然后答案二分

山头狙击战：（二分判断）

实际上就是二分最大情况和最小情况之间所有情况 

那个判断是否可行的算法应该是本题难点：

判断为真的条件就是每一次循环（模拟每一个敌人进攻的情况）准备所用的时间和敌人进攻时间的关系

如果不需要等敌人 就直接用之前过了的时间加上换弹时间和敌人作比较

如果需要等的话 将当前情况 还原为 和第一次一样的情况

假设这个敌人就是第一个敌人 那么等待时间就是他前进到这里的时间

#include <iostream> 
#include <algorithm>
#define INF 1e7 
using namespace std;

typedef long long LL; 

LL n,m;
LL a[100010];  //为什么LL a[maxn]不行？？？ 

bool p(LL x){
    LL tmp=0; //可以射杀状态时间 
    if(a[1]>m){
        tmp+=a[1]-m; //射杀所要时间就是 a[1]走到射程范围内的时间 
    }
    for(LL i=2;i<=n;i++){
        tmp+=x; //每次都要换弹
        if(tmp>a[i]){ //错误标记：写反了 应该是设计的人慢了就不可以了 
            return false;
        }  //一旦某一超过总时间 就回复错误 
        if(a[i]-tmp>m){ //几遍准备好了 还是在射程以外 
            tmp=a[i]-m; //相当于第一次的情况 也就是换好弹之后减去射程 这时候沙雕a[i]所用的时间就是等待a[i]进入射程以内的时间 
        } 
    }
    return true;
}
//在于如果每一次都以这个时间换单的话 每一次是否会能够达到敌人 

int main(){
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
    }
    sort(a+1,a+n+1);
    int l=0;
    int r=INF;
    int mid;
    LL ans;
    while(l<=r){
        if(p(mid=r+l>>1)){
            ans = mid, l=mid+1; 
        } else r=mid-1;
    }
    printf("%lld",ans); //这里也可以把ans替换成r-1这样就不用设ans了 
} 

//这道题里面是时间越长越不行 也就是 单调递减的关系  k越小可能性越大 k越大可能性越小 这种就是递减关系 

//这道题的bool部分最好重新打一遍 

三元一次方程的解：（二分判断）

  因为跟与跟之间相差大于等于1，所以可以二分两个整数之间的值查找答案

由于跟的范围在-100到100之间，所以将-100到100之间的值一一枚举

判断答案是否在i和i+1之间 如果在则进行二分

对于跟在边界的情况，可以直接判定跟是否在左边界

当答案到三个的时候 自动停止枚举

#include <iostream>
#include <iomanip>
using namespace std;

//如果把这里的小数设成float的话就会把-100到100全都输出 为什么？？？ 

double a,b,c,d;

double fac(double x){
	return a*x*x*x+b*x*x+c*x+d;
}

int main(){
	scanf("%lf%lf%lf%lf",&a,&b,&c,&d);
	int s=0,i;
	double l,r; 
	for(i=-100;i<=100;i++){
		l=i;
		r=i+1;  //千万不要错误地把r l设为int会出大事的 
		if(!fac(l)){
			cout<<fixed<<setprecision(2)<<l<<' ';
			s++;
		}
		if(fac(l)*fac(r)<0){ //答案在 这时候才有必要二分寻找答案 
		while(r-l>0.001){ //二分得三种情况： 答案在左边和中间之间 答案案在中间 答案案在中间和右边之间 
			double mid=(l+r)/2.0;
				if(fac(l)*fac(mid)<=0) //涵盖了前两种情况
					  r=mid;
				else l=mid; 
			}
			printf("%.2lf ",r);
			s++ ;
		}	
	 if(s==3) break;
	}
} 

   线性变换：（循环节）

由于T很大，直接模拟变换操作过程会导致超时，无法通过该题。

观察到对于相同下表P,进行一次线性变换的得到的下标P‘’是相同的，因此在百年换过程中，下标P的值一定是经过某一段区间后循环重复出现的并且循环节的长度一定不会超过n,我们只需要模拟前n+1次操作，即可得出循环节的长度以及每一次循环产生的贡献，这是，只需要计算在T轮操作内出现多少次循环即可快速计算出整块循环的答案，对于剩余的部分，可以通过之前维护的值直接算出，也可以通过模拟在O(n)的时间内算出，总体时间复杂度O（n）

#include <bits/stdc++.h>

using namespace std;
using ll=long long;

const int N=1e6+5;

void solve(){
    int n.p.k.b;
    ll T;
    cin>>n>>p>>k>>b>>T;
    vector<int> a(n);
}

for(int i=0;i<n;i++) cin>>a[i];

vector<int st(n, 0);
vector<int> q;
do{
    q.push_back(p);
    st[p]=1;
    p=(1ll*k*p+b) % n;
    } while (!st[p]);
    
    int pos=find(q.begin(), q.end(),p)-q.begin();
    for(int &i : q) i=a[i];
    
    vector<int> cir(q.begin()+pos, q.end());
    q=vector<int>(q.begin(), q.begin()+pos);
    
    ll dec=min(ll(q.size()), T);
    ll res=accumulate(q.begin(),q.begin+dec,0ll);
    
    T-=dec;
    if(T>0){
        int len=cir.size();
        ll tot=accumulate(cir.begin(),cir.end(),0ll);
        res+=T/len*tot + accumulate(cir.begin(),cir.begin+T%len,0ll);
    }
    
    cout<<res<<'\n';
    assert(res>=0);
}
int main{
solve();
return 0;
}