【2017/9/19】【校内胡策题】【noip模拟】【总结】

似乎永远用不完的图报

第一题

此题很有复习价值，本题中有几个点重点：

【1】 对于可行问题要往贪心方向思考

【2】 在想贪心方案是需要严格证明，宁可画上一定时间（但要控制再半小时以内）去证明正确性 ， 找反例

【3】 在想贪心情况时 ， 要落到实处 ，若觉得一个策略不对则需要通过题目特性落到实处看其是否正确；找反例时先感性想想反例出现情况，在去构造对应数据看是否能否定当前结论

在解决此题时 ， 由于放入体积与增加体积，而且题目问题是是否可解，可使人想到贪心；

而贪心策略中，由于要是其放得下，所以可以想到先放有贡献（增加体积）的情况 ， 然后猜测是贪心顺序，以a排序？b排序？还是b-a？此时发现它最后加完的体积是一个定值 ， 而其体积也在不断增加，那么应该是a越大的放到越后面能跟保险的放下，然而是否会有反例，根据其特性：v会应为b - a > 0 而不断增大，显而易见策略正确；

而此题头疼的是b - a < 0 时的策略 ： 还是按照上面所述的思路 ， a？，b？，b-a？，按照从大到小？从小到大？貌似从正面不好想，但有个性质时确定的：

最后的体积为定值

那么从次特性思考，倒着来想：

最后的状态是：

V + b1 + b2 + b3 + … + bn >= a1 + a2 + a3 + … + an

那么最后一次选择便是选择先将左式减去对于的b ， 在不等式成立的情况下在减去对应得a ，由于后面加上的是b - a < 0 ， 那么每次减去一组对应的a，b时左式减右式的值会越来越大 ， 所以只要保证每次删的b最小，时左式减小的尽量少，那么等式则月容易成立，所以嘛。。。反过来想 ， 不就是。。。以b为标准从大到小排序。。。

那么全程的贪心策略则出来了：

对于 a - b > 0 的情况 以a为标准从小到大排序

对于 a - b < 0 的情况 以b为标准从大到小排序

代码如下：

#include<cctype>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define M 100001
using namespace std;
long long T , n ;
long long v;
long long a , b;
long long qu1_tot , qu2_tot;
struct Queue{
long long a , b_a , b;
Queue(){a = b_a = 0;}
}qu1[M] , qu2[M];
bool cmp1(const Queue &x , const Queue &y){return x.a == y.a ? x.b_a > y.b_a : x.a < y.a;}

bool cmp2(const Queue &x , const Queue &y){return x.b == y.b ? x.a > y.a : x.b > y.b;}
long long read(){
long long an = 0;
static char ch = '*';
while(!isdigit(ch))ch = getchar();
while( isdigit(ch))an = an * 10 + ch - '0' , ch = getchar();
return an;
}
int main(){
T = read();
while(T--){
n = read() , v = read();
bool bre = true;
qu1_tot = 0 , qu2_tot = 0;
memset(qu1 , 0 , sizeof qu1);
memset(qu2 , 0 , sizeof qu2);
for(int i = 1 ; i <= n ; ++i){
a = read() , b = read();
long long b_a = b - a;
if(b - a >= 0)qu1[++qu1_tot].a = a , qu1[qu1_tot].b_a = b_a , qu1[qu1_tot].b = b;
else qu2[++qu2_tot].a = a , qu2[qu2_tot].b_a = b_a , qu2[qu2_tot].b = b;
}
sort(qu1 + 1 , qu1 + qu1_tot + 1 , cmp1);
sort(qu2 + 1 , qu2 + qu2_tot + 1 , cmp2);
for(int i = 1 ; i <= qu1_tot && bre ; ++i){
if(qu1[i].a > v)bre = false;
else v += qu1[i].b_a;
}
if(bre == false){
printf("No\n");
continue;
}
for(int i = 1 ; i <= qu2_tot && bre ; ++i){
if(qu2[i].a > v)bre = false;
else v += qu2[i].b_a;
}if(bre == false){
printf("No\n");
continue;
}
printf("Yes\n");
}
}

第二题

这道题由于时500000的上线而且为区间，很容易想到二分加线段树维护，代码如下（由于卡产只能得65分）（复杂度O（n * (log^3)））：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define M 1500001
using namespace std;
int n;
long long gcd(long long a , long long b){return b > 0 ? gcd(b , a%b) : a;}
long long v_num[M] , v_gcd[M];
int l[M] , r[M];
long long num[M];
long long tot , ans , set[M];
struct val{
long long gcd , num;
val(){gcd = 1 , num = (1 << 31) - 1;}
val(long long x , long long y){gcd = x , num = y;}
};
long long read(){
long long an = 0;
static char ch = '*';
while(!isdigit(ch))ch = getchar();
while( isdigit(ch))an = an * 10 + ch - '0' , ch = getchar();
return an;
}
void build(int l_ ,  int r_ , int v){
if(l_ == r_){
v_num[v] = v_gcd[v] = num[l_];
return;
}
l[v] = l_ , r[v] = r_;
int m_ = (l_ + r_) >> 1;
build(l_ , m_ , v << 1);
build(m_ + 1 , r_ , v << 1 | 1);
v_gcd[v] = gcd(v_gcd[v << 1] , v_gcd[v << 1 | 1]);
v_num[v] = min(v_num[v << 1] , v_num[v << 1 | 1]);
//  printf("[%d %d %I64d %I64d]\n",l_,r_,v_num[v] , v_gcd[v]);
}
val query(int l_ , int r_ , int qu_l , int qu_r , int v){
if(l_ >= qu_l && r_ <= qu_r)return val(v_gcd[v] , v_num[v]);
int m_ = (l_ + r_) >> 1;
val a , b , ret;
if(qu_l <= m_ && qu_r > m_){
a = query(l_ , m_ , qu_l , qu_r , v << 1);
b = query(m_ + 1 , r_ , qu_l , qu_r , v << 1 | 1);
ret.gcd = gcd(a.gcd , b.gcd);
ret.num = min(a.num , b.num);
}
else if(qu_l <= m_)ret = query(l_ , m_ , qu_l , qu_r , v << 1);
else if(qu_r >  m_)ret = query(m_ + 1 , r_ , qu_l , qu_r , v << 1 | 1);
return ret;
}
bool check(int lon){
for(int i = 1 ; i <=n - lon + 1 ; ++i){
val x = query(1 , n , i , i + lon - 1 , 1);
if(x.gcd == x.num)return true;
}
return false;
}
void find(int lon){
ans = lon * 1LL;
for(int i = 1 ; i <=n - lon + 1 ; ++i){
val x = query(1 , n , i , i + lon - 1 , 1);
if(x.gcd == x.num)  set[++tot] = i;
}

}
int main(){
freopen("point.in","r",stdin);
scanf("%d",&n);
for(register int i = 1 ; i <= n ; ++i){
num[i] = read();
//scanf("%I64d",&num[i]);
if(num[i] == 1){
printf("1 %d\n1",n - 1);
return 0;
}
}
build(1 , n , 1);
int L = 1 , R = n;
while(L + 1 < R){
int M_ = (L + R) >> 1;
check(M_) ? L = M_ : R = M_;
}
if(check(R))find(R);
else find(L);
printf("%I64d %I64d\n" , tot , ans - 1);
for(int i = 1 ; i <= tot ; ++i)printf("%I64d ",set[i]);
}

然而其实有更好的方法，由于时连续的区间，所以更具其【连续性】，那么每次维护一个以当前为ak而且是该区间最后一个数的满足条件的区间的长度和以当前为ak而且是该区间第一个数的满足条件的区间长；再来O（n）枚举即可

但是有一点需要注意，就是判重 ， （一个合理区间里有多个相同的数）

例子：

4

1 1 1 1

代码如下：（复杂度O（n））

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define M 1000001
using namespace std;
int n , ans = 0  , top , vis[M];
long long qu[M];
int pre[M] , nex[M];
long long  num[M];
int main(){
scanf("%d",&n);
for(int i = 1 ; i <= n ; ++i)scanf("%I64d",&num[i]);
for(int i = 1 ; i <= n ; ++i){
int set = i ; pre[i] = i;
while(set && num[set] % num[i] == 0)set = pre[set] == set ? set - 1 : pre[set];
pre[i] = set + 1;
}
for(int i = n ; i >= 1 ; --i){
int set = i ; nex[i] = i;
while(set < n + 1 && num[set] % num[i] == 0)set = nex[set] == set ? set + 1 : nex[set];
nex[i] = set - 1;
}
for(int i = 1 ; i <= n ; i++){
if(ans < nex[i] - pre[i]){
ans = nex[i] - pre[i];
memset(vis , 0 , sizeof vis);
top = 0;
}
if(ans == nex[i] - pre[i])
if(!vis[pre[i]]){
vis[pre[i]] = 1;
qu[++top] = pre[i];
}
}
printf("%d %d\n",top , ans);
for(int i = 1 ; i <= top ; i++)printf("%I64d ",qu[i]);
}