2015 Multi-University Training Contest 1 题集（长期更新）A B E

本来打算从2009年开始更的， 后来日天巨巨的意思是从最近的开始写；

感谢日天巨巨提供了整套标程， 这样就可以悄悄的在自己OJ里面交着玩了；

A题：OO’s Sequence

题目大意：给一个序列，这个序列中有很多个由L，R构成的子区间，然后要求出每个子序列中的  数字不能整除当前子序列的个数后的和；

题解：最暴力思路，对于每一个子序列中的数， 对它进行查询是否存在满足条件的数字，但是肯   定会TLE；所以考虑优化，对于每个子序列中的每个数字，进行二分思想，搜出满足条件；       并且对于当前数字a[i]，找到最左的区间和最右的区间,满足这样的区间有：

    (i-l[i]+1)*(r[i]-i+1)个；对于第i个数，找到两个最靠近他的两个因子的位置

举例：1 2 5 6 3 7 8 9； 对于6（第4位） ， 最左边的因子是2（第2位），最右边3（第5位）

则6这个数字出现的区间就是（4-2）*（5-4）个区间内；

AC代码：

<strong>#include <bits/stdc++.h>
#define inf 0xfffffff
#define ll long long
#define maxn 100010
using namespace std ;
ll  a[maxn] , l[maxn] , r[maxn], vis[maxn] ;
const __int64 mod=1000000007;
int main()
{
    int n ;
    while(cin>>n)
    {
        memset(a,0,sizeof(a));
        memset(l,0,sizeof(l));
        memset(r,0,sizeof(r));
        memset(vis,-1,sizeof(vis));
        ll  maxv = 0 ;
        for(int i = 0 ; i < n ; i++) 
        {
        	scanf("%lld",&a[i]);
			maxv = max(maxv , a[i]);
		}
        for(int i = 0 ; i < n ; i++)
        {
            if(vis[a[i]] == -1)
            {
                l[i] = i + 1  ;//*保存满足当前节点的左下标
            }
            else l[i] = i - vis[a[i]] ;//*如果搜到头了， 不包括它本身， 所以减去自己
            for(int j = a[i] ; j <= maxv ; j+=a[i])   vis[j] = i ; //*标记一下
            
        }
        memset(vis,-1,sizeof(vis));
        for(int i = n-1; i >= 0; i--)
        {
            if(vis[a[i]]==-1) r[i] = n - i ;
            else r[i] = vis[a[i]] - i ;
            for(int j = a[i] ; j<=maxv ; j+=a[i])	vis[j] = i ;
        }
        ll res = 0 ;
        for(int i = 0 ; i < n ;i++)
        {
            res += l[i]*r[i];
            res%=mod;
        }
        printf("%lld\n",res);
    }
    return 0 ;
}
</strong>

B题：Assignment

题目大意：问有一个序列，长为n；给出一个k，问在所有可能的区间内，存在多少个最大值减去最小值的答案比k小， 求出个数；

算法：学习了一下倍增法求RMQ，这样可以查询区间的最大值最小值；之后对区间进行二分处理， 以此来枚举出所有区间并且查询区间值和k值比较。

           枚举出左短点l，然后二分得到右端点 ，则满足的集合为（l - r + 1 ) ;

AC代码：

<strong>#include <bits/stdc++.h>
#define ll long long
#define maxn 100010
using namespace std ;
int maxsum[maxn][30] , minsum[maxn][30] , a , n , k ;
void RMQ()
{
    for(int j = 1 ; (1<<j) <= n ; j++)
    for(int i = 1 ; i + (1<<j) -1 <=n ; i++)
    {
        int m = 1<<(j-1);
        maxsum[i][j] = max(maxsum[i][j-1] , maxsum[i+m][j-1]);
        minsum[i][j] = min(minsum[i][j-1] , minsum[i+m][j-1]);
    }
}
int query(int i , int j)
{
    int maxi , mini ;
    int k = log2(j - i + 1.0) ;
    maxi = max(maxsum[i][k] , maxsum[j-(1<<k)+1][k]);
    mini = min(minsum[i][k] , minsum[j-(1<<k)+1][k]);
    return maxi - mini ;
}
int main()
{
    int t ;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&k);
        for(int i = 1 ; i<=n;i++) scanf("%d",&a) , maxsum[i][0] = minsum[i][0] = a ;
        RMQ();
        ll ans = 0 ;
        for(int i = 1 ; i<=n ; i++)
        {
            int l = i , r = n ;
            while(l+1<r)
            {
                int mid = (l+r)>>1;
                if(query(i,mid)<k) l = mid ;
                else r = mid ;
            }
            if(query(i,r) < k) ans+=(r - i + 1);
            else ans+=(l-i+1);
        }
        cout<<ans<<endl;
    }
    return 0 ;
}
</strong>

E题：Pocket Cube

题目大意：给你一个2阶魔方的示意图，是否能还原回最初的模式：

题解：首先要知道魔方的构造：黄对白、红对橙、蓝对绿； 所以还原只需要针对其中的一对只要匹配了就可以了；对于二阶魔方，当回到最初的位置不重复的转动三下即可，

           并且相同颜色的块每次到达的位置总是不一样的，所以互不影响。所以个人的处理是将某一颜色（两块），上面一个标记为1，下面一个为-1；那么相邻的另外一个颜色

           就是上面为-1.下面为1；到达下次转动仍旧保持了这个特性，仍旧是这个值；注意题中的初始化是按，读入2 ， 2 ， 6 ，6, 2 ，2 来代表24个格子的（随后上图）；

           初始化后去匹配任意一对颜色，如果遇到了就加上当前位置的权值，租最后看能否取余3；如果可以，则可以还原，否则不能；（玩魔方的定理，我也不懂）；

图解：

        

AC代码：

#include <bits/stdc++.h>
using namespace std ;
int a[24] = {-1,1,1,-1,1,-1,0,0,1,-1,-1,1,0,0,-1,1,-1,1,1,-1,0,0,0,0};  //*按顺序初始化
int main()
{
	char s[3] ;
	int t ;
	cin>>t;
	for(int cas = 1 ; cas<=t ; cas++)
	{
		int ans = 0 ;
		for(int i = 0 ; i<24 ; i++)
		{
			cin>>s;
			if(s[0]=='y'||s[0]=='w')
			{
				ans+=a[i];
			}
		}
		printf("Case #%d: ",cas);
		if(ans%3==0) printf("YES\n");
		else printf("NO\n");
	}
	return 0 ;
}