2016_Matrix_Warm_Up_2

http://acm.hust.edu.cn/vjudge/contest/130363#overview

 

比赛

 

A 题意:每个题目有难度1-10, 可能被泄露, 以及是否通过.  求多少对可疑记录,  可疑记录对定义为 泄露的题目通过了,却没通过难度低,没泄露的题目.

解法: on统计每个难度1-10有多少题满足没泄露且没通过,  然后再on遍历,对每个泄露且通过的题目, 所有难度比他低的记录都能构成一对答案,累加.

 

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=1e5+10;
int n;
struct G{
    int d,flag;
    char c[4];
}g[M];
LL sum[16];
void init(){
    mt(sum,0);
    for(int i=0;i<n;i++){
        if(!g[i].flag&&g[i].c[0]=='i'){
            sum[g[i].d]++;
        }
    }
    for(int i=2;i<=10;i++){
        sum[i]+=sum[i-1];
    }
}
LL solve(){
    init();
    LL answer=0;
    for(int i=0;i<n;i++){
        if(g[i].flag&&g[i].c[0]=='c'){
            answer+=sum[g[i].d-1];
        }
    }
    return answer;
}
int main(){
    #ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif // txtout
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i=0;i<n;i++){
            scanf("%d%d%s",&g[i].d,&g[i].flag,g[i].c);
        }
        printf("%lld\n",solve());
    }
    return 0;
}

 

 

 B 题意：给月份和该月第一天是星期几，问该月有几个星期五和星期六。

解法：得到月份和星期，然后遍历每一天统计。

 

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=1e5+10;
char month[32][32]={"JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC"};
int day[32]={31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30 ,31};
char weekday[32][32]={"SUN","MON","TUE","WED","THU","FRI","SAT"};
char a[M];
char b[M];
int getMonth(){
    for(int i=0;i<12;i++){
        if(!strcmp(a,month[i])) return i;
    }
    return -1;
}
int getWeek(){
    for(int i=0;i<7;i++){
        if(!strcmp(b,weekday[i])) return i;
    }
    return -1;
}
int solve(){
    int m=getMonth();
    int w=getWeek();
    int d=day[m];
    int sum=0;
    for(int i=1;i<=d;i++){
        if(w==5||w==6){
            sum++;
        }
        w=(w+1)%7;
    }
    return sum;
}
int main(){
    #ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif // txtout
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%s%s",a,b);
        printf("%d\n",solve());
    }
    return 0;
}

 

 

C  等待补充。

 

D 题意：给一个字符串，问构造一个与其长度一样的串，最长公共子序列的长度最短为多少。

解法: 贪心的选取一个原串出现次数最少的字符，全用这个字符构成一个串，最长公共子序列的长度就是这个字符在原串中出现次数。

 

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=1e5+10;
char a[M];
int sum[32];
int solve(){
    mt(sum,0);
    for(int i=0;a[i];i++){
        sum[a[i]-'a']++;
    }
    int answer=inf;
    for(int i=0;i<26;i++){
        answer=min(answer,sum[i]);
    }
    return answer;
}
int main(){
    #ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif // txtout
    int t,cas=1;
    scanf("%d",&t);
    while(t--){
        scanf("%s",a);
        printf("Case %d: %d\n",cas++,solve());
    }
    return 0;
}

 

 

E 题意：输入n，求2-n所有F（i）的和， F[i]是 i 所有因子的和。

解法：枚举每个数，其倍数的位置都加上这个数，这个的复杂度是 n/1+n/2+n/3+...+n/n= n*(1/1+1/2+1/3+1/4) ~= n*ln（n）.  调和级数。然后再求个前缀和，查询O1。

 

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=2e7+10;
int n;
LL a[M];
void init(){
    for(int i=2;i<M;i++){
        a[i]=1;
    }
    for(int i=2;i<M;i++){
        for(int j=i;j<M;j+=i){
            a[j]+=i;
        }
    }
    for(int i=3;i<M;i++){
        a[i]+=a[i-1];
    }
}
int main(){
    #ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif // txtout
    init();
    while(~scanf("%d",&n),n){
        printf("%lld\n",a[n]);
    }
    return 0;
}

 

 F 题意: 从n*m的矩阵中,选取一个平行于边界的子矩阵, 子矩阵的值表示高度, 他们会选一个点开party, 这个点满足所有点到这个点的距离和最小,如果多个点满足条件,会选取高度最高的. 选出这个点以后, 和查询的h比较,如果这个点的高度<h,party取消. 查询h, 对每个h , 输出能选出的最大面积的子矩形, 满足上述约束.

 

解法: 暴力, 枚举出一个子矩阵, n^4, 判断是否满足约束，满足就更新答案。  判断， 暴力的话枚举找开party的点，依次和所有点做差， 得到距离和最小的，相同选高度最高的， n^4, 然后判断 是否<h.  

T*Q*n^8。

第一步优化：优化判断，将所有子矩阵的点排序，对于最大Hn的和最小H1的两个点来说，选取任意一个点Hi，他们两个的距离和  Hn-Hi  + Hi-H1  都等于他们的距离 Hn - H1 ，那么这两个元素就可以消去了，明显贪心的选取中间的会更好，  如果选两个元素之外的， 距离明显增加。  以此类推， 相当于求中位数的过程。 当n 为奇数时， 选取的点 唯一，  当n 为偶数时， 根据题意选取 h大的。

所以 ， 对于查询 h 来说， 一个子矩阵是否满足约束， 条件转化为， 该子矩阵中位数（偶数时是中间两个数较大的那个数，不是数学定义里的中位数）要 〉=h。再进一步转化，子矩阵中〉=h的个数要超过一半。

当n为偶数时，（大于等于h的个数）要〉=n/2。 当n为奇数的时候（大于等于h的个数）要〉=n/2+1. 

此时，对于一个查询 h ，可以n^2预处理， 将〉=h的点设为1，将<h 的设为0。然后n^2预处理出sum[x][y]，表示 （1，1）到（x，y）子矩阵的和。 然后n^4枚举子矩阵，O1判断，判断方法就是求该子矩阵1的个数是否》=总个数/2， 求任意一个子矩阵的和， 可以容斥原理， sum[x2][y2] - sum[x2][y1-1] -sum[x1-1][y2] + sum[x1-1][y1-1];

目前复杂度只剩枚举子矩阵，  T*Q*n^4。  但还是超时。 还要优化 。

先做一个预处理，〉=h设置为1，<h设置为-1 ， 上述约束转化为子矩阵的和>=0。

首先n^2枚举出子矩阵的左边界和右边界，然后用一维数组 s[i] 记录 第 i 行在界内的和。 枚举行on， 用前缀和o1求， 这里的复杂度是 on3。

问题转化为了， 在s这个一维数组中，找到一段连续的子段，在满足子段和>=0的情况下，使得子段尽可能长。因为这样面积就大了。

处理这个问题，n2枚举起点终点，用前缀和o1判合法， 是可行的， 但是复杂度就回到 n4了。

设起点x+1，终点y，   约束就是   S[y]-S[x]>=0 ,  子段长度就是  y - x，

我们考虑处理出单调序列，然后双指针。

开始时序列为空，从前往后枚举S[i] ， 作为 S[x]，  当序列为空时，将s[ i ]加入序列， 当序列不为空时， 只有s[i] 的值小于序列最后一个元素的值，才加入序列尾部。

原因是，我们希望x越小越好， sx也越小越好，这样更有可能满足条件，也更有可能更新答案，  那么当来一个元素 ， 我们尝试用它作为sx时， 因为我们从前往后枚举， 所以x显然已经比之前的大了，只有sx比之前的小，才有可能找到更好的解，否则之前的解一定更好。

经过这次on，我们处理出了一个sx序列，序号x递增，值sx递减的序列。

同理，我们从后往前枚举si， 作为sy。 当序列为空时， 加入， 当不为空时， 只有当 sy的值大于序列最后一个元素的值，才加入序列尾部。

原因是，我们希望y越大越好， sy也越小越好，这样更有可能满足条件，也更有可能更新答案，  那么当来一个元素 ， 我们尝试用它作为sy时， 因为我们从后往前枚举， 所以y显然已经比之前的小了，只有sy比之前的大，才有可能找到更好的解，否则之前的解一定更好。  （多目标优化的非支配解集，这个序列实际上）

经过这次on，我们处理出了一个sy序列，序号y递减，值sy递增的序列。

下面我们用两个指针来枚举解，复杂度2 n。

i 枚举sy中每一个元素， j开始时停在sx的尾部。

对于每个i ，  j一开始在sx 最小的地方，

如果满足，就更新答案，j--。 因为当前满足了， 所以我们尝试让sx 增大一点， 这样x就减少了，如果还〉=0，那还能进一步更新答案，如果不合法了，说明我们已经枚举完 i 结尾的所有情况了。

当i++的时候 j停在原地， 所以能2n， 停在原地是对的的原因是， i++导致sy增大， 那么 sx可能不变，也可能增大，不会去减小，减小使得x增加，对答案没有好处。

 

 单调的两个指针  使得这步复杂度on， 整体TQn3

 

//#define txtout
//#define debug
#include<bits/stdc++.h>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
const double pi=acos(-1.0);
const double eps=1e-8;
const int inf=0x3f3f3f3f;
const int M=1e3+10;
int n,m,lq;
int a[M][M];
int b[M][M];
int sum[M][M];
int q[M];
int answer[M];
int buffer[M];
typedef pair<int,int> pii;
pii tail[M],head[M];
void init(int h){
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            b[i][j]=1;
            if(a[i][j]<h){
                b[i][j]=-1;
            }
            sum[i][j]=b[i][j];
            if(j){
                sum[i][j]+=sum[i][j-1];
            }
        }
    }
}
int get_buffer(){
    for(int i=1;i<n;i++){
        buffer[i]+=buffer[i-1];
    }
    if(buffer[n-1]>=0) return n;
    int answer=0;
    int len_tail=0;
    for(int i=n-1;i>=0;i--){
        if(buffer[i]>=0){
            answer=max(answer,i+1);
        }
        int s=len_tail;
        if(s==0){
            tail[len_tail++]=make_pair(buffer[i],i);
            continue;
        }
        if(buffer[i]>tail[s-1].first){
            tail[len_tail++]=make_pair(buffer[i],i);
        }
    }
    int len_head=0;
    for(int i=0;i<n;i++){
        int s=len_head;
        if(s==0){
            head[len_head++]=make_pair(buffer[i],i);
            continue;
        }
        if(buffer[i]<head[s-1].first){
            head[len_head++]=make_pair(buffer[i],i);
        }
    }
    for(int i=0,j=len_head-1;i<len_tail&&j>=0;i++){
        if(tail[i].second<=answer) break;
        while(j>=0&&tail[i].first-head[j].first>=0){
            answer=max(answer,tail[i].second-head[j].second);
            j--;
        }
    }
    return answer;
}
int get(int h){
    init(h);
    int answer=0;
    for(int x=0;x<m;x++){
        for(int y=x;y<m;y++){
            if(answer>=(y-x+1)*n) continue;
            for(int i=0;i<n;i++){
                int value=sum[i][y];
                if(x){
                    value-=sum[i][x-1];
                }
                buffer[i]=value;
            }
            answer=max(answer,(y-x+1)*get_buffer());
        }
    }
    return answer;
}
void solve(){
    for(int i=0;i<lq;i++){
        answer[i]=get(q[i]);
    }
}
int main(){
    #ifdef txtout
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    #endif // txtout
    int t,cas=1;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                scanf("%d",&a[i][j]);
            }
        }
        scanf("%d",&lq);
        for(int i=0;i<lq;i++){
            scanf("%d",&q[i]);
        }
        solve();
        printf("Case %d:\n",cas++);
        for(int i=0;i<lq;i++){
            printf("%d\n",answer[i]);
        }
    }
    return 0;
}

 

 

end