洛谷P1419
这道题就是找到一个最大的平均段落值，这里的计算方式，可以用二分的思想，按照平均数去二分，查找这个可能的平均数，然后在用一个单调队列滑动窗口去进行维护一个【S，T】区间内的最值，这样就可以得到了结果。二分的判断条件就是，因为要找到平均数的最大值，就是每个数减去平均值后，如果在某个【S,T】的序列的时候，这个区间的差值平均值大于0，说明还有更大的平均数，否则就因为过大了，return false。这样就解决了。区间的值，可以用前缀和去差值计算。
#include<bits/stdc++.h>
using namespace std;
const int N=100005;
const double eps=1e-4;
int n,S,T,a[N];
double b[N],sum[N];
bool check(double k){
for(int i=1;i<=n;i++)
b[i]=a[i]-k;
for(int i=1;i<=n;i++)
{
sum[i]=sum[i-1]+b[i];
}
deque<int>q;
for(int i=S;i<=n;i++)
{
while(!q.empty()&&q.front()<i-T) q.pop_front();
while(!q.empty()&&sum[q.back()]>sum[i-S]) q.pop_back();
q.push_back(i-S);
if(sum[i]-sum[q.front()]>=0) return true;
}
return false;
}
int main()
{
scanf("%d %d %d",&n,&S,&T);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
double l=-1e4,R=1e9;
while(abs(R-l)>eps){
double mid=(l+R)/2;
if(check(mid)){
l=mid;
}else{
R=mid;
}
}
printf("%.3lf",l);
return 0;
}
洛谷P1083：
这个题同样可以用二分的思想，就是说，二分订单的数量，数量越少肯定满足的情况的可能性越大，这样就可以通过二分订单的数量来解决这个问题。我们可以轻松通过差分的思想，实现区间的加减。二分的判断条件就是，一旦有一天的订单数量不足以满足情况，就直接return true。去减少订单数量。
#include<bits/stdc++.h>
using namespace std;
int r[1020501];
int d[1020501];
int s[1020501];
int t[1020501];
int sum[1020501];
int n,m;
bool check(int x)
{
for(int i;i<=n;i++)
sum[i]=0;
for(int i=1;i<=x;i++)
{
sum[s[i]]+=d[i];
sum[t[i]+1]-=d[i];
}
for(int i=1;i<=n;i++)
{
sum[i]+=sum[i-1];
if(sum[i]>r[i]) return true;
}
return false;
}
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
cin>>r[i];
for(int i=1;i<=m;i++)
cin>>d[i]>>s[i]>>t[i];
int l=0,r=m;
int ans=0;
while(l<=r)
{
int mid=(l+r)/2;
if(check(mid)){
ans=mid;
r=mid-1;
}
else l=mid+1;
}
if(ans==0)
cout<<ans<<endl;
else cout<<"-1"<<endl<<ans<<endl;
}
洛谷P1314
质检员问题，显而易见，通过对W的判断可以改变y的数值。
当是s-y>0 说明了y过小，让W减少，标准放宽，那么y的数值就会变大。
当s-y<0 说明y过大了，让W增大，标准变窄，那么y的数值就会变小。
根据这个就可以进行二分。 区间值的计算依旧可以使用前缀和做差的方式进行计算。
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
using ll=long long;
int n,m,w[N],v[N],l[N],r[N];
ll s;
ll ans=1e13,sumn[N],sumv[N];
bool check(int W){
for(int i=1;i<=n;i++){
sumn[i]=sumn[i-1];
sumv[i]=sumv[i-1];
if(w[i]>=W){
sumn[i]+=1;
sumv[i]+=v[i];
}
}
ll y=0;
for(int i=1;i<=m;i++)
{
y+=(sumn[r[i]]-sumn[l[i]-1])*(sumv[r[i]]-sumv[l[i]-1]);
}
ans=min(ans,abs(s-y));
if(y>s) return true;
else return false;
}
int main(){
scanf("%lld%lld",&n,&m,&s);
for(int i=1;i<=n;i++){
scanf("%d%d",&w[i],&v[i]);
}
for(int i=1;i<=m;i++){
scanf("%d%d",&l[i],&r[i]);
}
int l=0,r=1e6;
while(l<=r){
int mid=(l+r)/2;
if(check(mid)){
l=mid+1;
}else{
r=mid-1;
}
}
printf("%lld",ans);
return 0;
}
P4552
题意：就是说，在一个序列中，选择一个区间【l,r】让这个序列全部加一，或者全部减一。
问需要多少次，才可以使得这个序列所有数字变成一样的。同时，这个一样的序列有多少种情况。
#include<bits/stdc++.h>
using namespace std;
const int N=100005;
using ll=long long;
int n,a[N],d[N];
ll x,y;
int mian(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
}
for(int i=1;i<=n;i++){
d[i]=a[i]-a[i-1];
}
for(int i=2;i<=n;i++)
{
if(d[i]>0) x+=d[i];
else y+=-d[i];
}
printf("%lld\n%lld",(ll)max(x,y),(ll)abs(x-y)+1);
return 0;
}树状数组可以是实现快速的单点修改区间查询，同时这个方式，用差分数组也可以实现的。
附上板子：
#include<bits/stdc++.h>
using namespace std;
#define MAXN 50005
#define lowbit(x) ((x)&(-x))
int tree[MAXN];
inline void update(int i,int x)
{
for(int pos=i;pos<MAXN;pos+=lowbit(pos))
{
tree[pos]+=x;
}
}
inline int query(int n){
int ans=0;
for(int pos=n;pos;pos-=lowbit(pos))
ans+=tree[pos];
return ans;
}
int main()
{
int T;
cin>>T;
while(T--)
{
memset(tree,0,sizeof(tree));
int n,x,a,b;
char opr[10];
cin>>n;
for(int i=1;i<=n;i++)
{
scanf("%d",&x);
update(i,x);
}
while(scanf("%s",opr),opr[0]!='E')
{
switch(opr[0])
{
case 'A':
cin>>a>>b;
update(a,b);
break;
case 'S':
cin>>a>>b;
update(a,-b);
break;
case 'Q':
cin>>a>>b;
cout<<query(a,b);
}
}
}
}同时树状数组可以去解决这个逆序对的问题。
#include<bits/stdc++.h>
using namespace std;
#define lowbit(x) ((x)&(-x))
#define MAXN 500010
using namespace std;
typedef long long ll;
ll read()
{
ll ans=0;
char c=getchar();
while(!isdigit(c))
c=getchar();
while(isdigit(c))
{
ans=ans*10+c-'0';
c=getchar();
}
return ans;
}
ll tree[MAXN];
inline void update(ll i,ll x)
{
for(ll pos=i;pos<MAXN;pos+=lowbit(pos))
tree[pos]+=x;
}
inline ll query(int n)
{
ll ans=0;
for(ll pos=n;pos;pos-=lowbit(pos))
ans+=tree[pos];
return ans;
}
inline query(ll x,ll y)
{
return query(y)-query(x-1);
}
int A[MAXN];
typedef struct{
ll value,id;
}mypair;
mypair B[MAXN];
bool cmp(mypair x,mypair y)
{
if(x.value<y.value)
{
return true;
}
return false;
}
int main()
{
ll n=read(),sum=0;
for(int i=1;i<=n;i++)
{
B[i].value=read();
B[i].id=i;
}
sort(B+1,B+n+1,cmp);
for(int i=1;i<=n;i++)
{
A[B[i].id]=i;
}
for(int i=1;i<=n;i++)
{
sum+=query(A[i]);
update(A[i],1);
}
sum=n*(n-1)/2-sum;
cout<<sum<<endl;
return 0;
}
求逆序对的算法除了归并排序。
HH的项链：
给定长度为n 的序列, 有m 次询问, 每次询问[ l , r ] 中不同数字的个数.
这个思路的做法核心是离线查询的思维, 线段树和树状数组只是为了维护区间贡献.
我们考虑将所有的查询存储下来, 按照右端点r rr进行小到大排序.
在处理询问时, 我们假设一个pos变量, 表示当前树中已经维护了前p o s pospos个位置的情况, 每次我们都让p o s pospos维护到当前查询的右边界r rr, 这样就保证了树中维护的区间是[ 1 , r ] [1, r][1,r].
#include<bits/stdc++.h>
#define rep(i,n) for(int i=1;i<=n;i++)
using namespace std;
typedef long long ll;
const int N=5e4+10,M=N<<2;
int w[N],res[M];
struct operation{
int l,r,id;
bool operator <(const operation& t) const {return r<t.r;}
};
vector<operation> area;
int t[N];
int lowbit(int x)
{
return x&(-x);
}
void add(int x,int c)
{
for(int i=x;i<N;i+=lowbit(i))
t[i]+=c;
}
int ask(int x){
int res=0;
for(int i=x;i;i=i-lowbit(i))
res+=t[i];
return res;
}
int ask(int l,int r)
{
return ask(r)-ask(l-1);
}
int main()
{
int n;
cin>>n;
rep(i,n){
cin>>w[i];
}
int m;
cin>>m;
rep(i,m){
int l,r;
cin>>l>>r;
area.push_back({l,r,i});
}
sort(area.begin(),area.end());
unordered_map<int,int>mp;
int pos=0;
for(auto& op:area){
int l=op.l,r=op.r,id=op.id;
while(pos+1<=r){
pos++;
add(pos,1);
if(mp[w[pos]]) add(mp[w[pos]],-1);
mp[w[pos]]=pos;
}
res[id]=ask(l,r);
}
rep(i,m) cout<<res[i];
return 0;
}
set是自动会按照从小到大的顺序自动进行排序的，但是也可以按照自己的想法去自动的去排序。
计算一个有根的二叉树的导出子图是满二叉树的个数问题：
其实就是 n是节点数
n+（n-1）/2+((n-1)/2-1)/2+.....；
其实原理很简单，就是把前n组数直接取模前缀和，把这样的数统计位置，以后如果说缺少了哪个数直接输出 整组的m个数和这个数。 也就是每次计算的时候，加速计算 直接按照m组m组的加。
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int maxn=200010;
const int mod=1e9+7;
int n,m;
int k,x,y;
int b[maxn];
int a[maxn];
int pre[maxn];
int num[maxn];
void solve(){
cin>>n>>m>>x;
for(int i=0;i<n;i++)
{
num[i]=-1;
}
pre[0]=0;
for(int i=1;i<=m;i++)
{
cin>>a[i];
pre[i]=pre[i-1]+a[i];
pre[i]%=n;
if(num[pre[i]]==-1)
{
num[pre[i]]=i;
}
}
int ans=-1;
for(int i=1;i<=n;i++)
{
int tmp=n-x;
if(!x){
ans=(i-1)*m;
break;
}
if(num[tmp]!=-1){
ans=(i-1)*m+num[tmp];
break;
}
x=(x+pre[m])%n;
}
printf("%lld\n",ans);
}
signed main()
{
solve();
return 0;
}优先队列的排序问题，就是直接定义一个结构体，并且在结构体，里面直接进行bool operator进行排序，然后在引用的时候，直接是使用priority_queue进行引用就可以。
H - Tokens on the Segments（贪心+优先队列）_天黑了也有灯打开的博客-优快云博客
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+10;
struct node{
int l,r;
bool operator <(node a)const{
if(l==a.l) return r>a.r;
return l>a.l;
}
}str[maxn],tt;
int main()
{
int t;
cin>>t;
while(t--)
{
priority_queue<node>q;
int n;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>str[i].l>>str[i].r;
q.push(str[i]);
}
int num=0;
int maxx=0;
while(!q.empty()){
tt=q.top();
q.pop();
if(tt.l>maxx){
maxx=tt.l;
num++;
}
else if(tt.l<tt.r){
tt.l++;
q.push(tt);
}
}
cout<<num<<endl;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
