JXNU-2015-10-月赛

1001  组合数取模，DP ，由组合数递推公式C(n,m)=C(n-1,m)+C(n-1,m-1)

 可设dp[i][j]为：i个数里取j个数的方案数，递推公式为：dp[i][j]=(dp[i-1][j-1]+dp[i-1][j])%mod

预处理储所有情况，然后对于每一个询问直接输出就好了

算法复杂度o(n*n)

1002 线段树成段更新 模板题了

算法复杂度o(n*log(n))

1003 素数判定 比较水的题 不要思维定势一上来就是筛法求素数，那样会导致TLE，因为筛法算法复杂度为o(n*log(log(n)))，而直接素数判定的算法复杂度时o(sqrt(n))

1004 字符串处理 只要把字符串统一映射成该字符串对各个字符拍完序后的字符串就行了，然后用map即可搞定

1005 对于数n，事实上它被反转的次数等于它约数的个数，如该约数个数为奇数，那么开关最后才是开的，事实上只有完全平方数的约数个数维奇数。

那么也就是说如果n为完全平方数，它就是开的。这道题就转化成，1～n有多少个数时完全平方数，总数刚好等于sqrt(n)

所以问题又转化成求平方跟，由于n是大数，所以用大数运算二分一下就好了。

设len为整数的位数，则算法复杂度为o(len^3)

1006 状态压缩DP 枚举每一行的状态即可

设dp[i][j]为前i行状态为j时取得的最大值，b[i][j]为第i行状态为j时数的总和

状态转移方程式 dp[i][j]=max(dp[i-1][k])+b[i][j]

算法复杂度o(n*2^(2*k))

1007 dfs 暴力枚举出所有情况之然后判定下是否有冲突就行了，注意蹩脚的情况。

1008 字符串处理 注意，字符串中连续出现有5个“1”的时候，立即填充一个“0”即可，写程序时不要写成cnt=6时往前插入一个"0"，因为这样写在最后刚好出现“11111”的时候就错了，这是一个坑点。

算法复杂度o(n)

总的来说，前面四道题时原题，不难的，从最后的情况看，大家刷的题太少了，以至致于是原题都看不出来。

以下是代码

1001

#include<iostream>
#include<cstdio>
#define LL long long
#define mod 1000000007
using namespace std;
const int maxn=1005;
LL dp[maxn][maxn];
void init()
{
    for(int i=0;i<maxn;i++) dp[i][0]=1;
    for(int i=1;i<maxn;i++)
        for(int j=1;j<=i;j++)
        dp[i][j]=(dp[i-1][j]+dp[i-1][j-1])%mod;
}
int main()
{
    init();
    int n,m;
    while(~scanf("%d%d",&n,&m)) printf("%I64d\n",dp[n][m]);
    return 0;
}

  1002

#include <cstdio>
#include <algorithm>
using namespace std;
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
#define LL long long
const int maxn = 100005;
LL add[maxn<<2];
LL sum[maxn<<2];
void PushUp(int rt)
{
    sum[rt] = sum[rt<<1] + sum[rt<<1|1];
}
void PushDown(int rt,int m)
{
    if (add[rt])
    {
        add[rt<<1] += add[rt];
        add[rt<<1|1] += add[rt];
        sum[rt<<1] += add[rt] * (m - (m >> 1));
        sum[rt<<1|1] += add[rt] * (m >> 1);
        add[rt] = 0;
    }
}
void build(int l,int r,int rt)
{
    add[rt] = 0;
    if (l == r)
    {
        scanf("%I64d",&sum[rt]);
        return ;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUp(rt);
}
void update(int L,int R,int c,int l,int r,int rt)
{
    if (L <= l && r <= R)
    {
        add[rt] += c;
        sum[rt] += (LL)c * (r - l + 1);
        return ;
    }
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    if (L <= m) update(L , R , c , lson);
    if (m < R) update(L , R , c , rson);
    PushUp(rt);
}
LL query(int L,int R,int l,int r,int rt)
{
    if (L <= l && r <= R)
    {
        return sum[rt];
    }
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    LL ret = 0;
    if (L <= m) ret += query(L , R , lson);
    if (m < R) ret += query(L , R , rson);
    return ret;
}
int main()
{
    int N , Q;
    while(~scanf("%d%d",&N,&Q))
    {
        build(1 , N , 1);
    while (Q --)
    {
        char op[2];
        int a , b , c;
        scanf("%s",op);
        if (op[0] == 'Q')
        {
            scanf("%d%d",&a,&b);
            printf("%I64d\n",query(a , b , 1 , N , 1));
        }
        else
        {
            scanf("%d%d%d",&a,&b,&c);
            update(a , b , c , 1 , N , 1);
        }
    }
    }
    return 0;
}

1003

#include<cstdio>
int judge(int n)
{
    if(n<2) return 0;
    for(int i=2;i*i<=n;i++)
        if(n%i==0) return 0;
    return 1;
}
int main()
{
    int n;
    while(~scanf("%d",&n))
        if(judge(n)) puts("YES");
        else puts("NO");
    return 0;
}

1004

#include<iostream>
#include<map>
#include<algorithm>
using namespace std;
struct node
{
    string id;
    string s[105];
    int pos;
}a[105];
int main()
{
    string s,str;
    map<string,int>m;
    int cnt=0;
    for(int i=0;i<105;i++) a[i].pos=0;
    while(cin>>s&&s!="XXXXXX")
    {
        str=s;
        sort(str.begin(),str.end());
        if(m.find(str)!=m.end())
        {
            int p=m[str];
            a[p].s[a[p].pos++]=s;
        }
        else
        {
            m[str]=cnt;
            a[cnt].s[a[cnt].pos++]=s;
            a[cnt].id=str;
            cnt++;
        }
    }
    while(cin>>s&&s!="XXXXXX")
    {
        sort(s.begin(),s.end());
        if(m.find(s)!=m.end())
        {
            int p=m[s];
            sort(a[p].s,a[p].s+a[p].pos);
            for(int i=0;i<a[p].pos;i++)
                cout<<a[p].s[i]<<endl;
        }
        else cout<<"NOT A VALID WORD"<<endl;
        cout<<"******"<<endl;
    }
    return 0;
}

1005

本题是我的原创题，网上搜不到题解了吧，嘿嘿
一看题，很简单的模拟呀，再一看数据量，懵逼了。。。哈哈，下面请看我慢慢分析吧
考虑编号为n的开关，它被反转的次数等于它约数的个数。
考虑到这一点就比模拟快许多了，但这个数据量统计约数的个数还是不够快呀，那就继续分析吧。
显然，只要知道n的约数的个数的奇偶性就可以了。
在这里又有一个很显然的结论，就是如果n是完全平方数，那么它的约数个数为奇数个，否则为偶数个。
原因很简单，因为约数总是成对出现的。但是完全平方数的平方根只能算作一个数，而不能算作两次。
那么接下来的问题就简单了。只需要判断区间[1,n]里有多少个完全平方数就可以了。
其实总个数就等于sqt(n)的整数部分。
求平方根很简单呀，令x=[sqrt(n)]，“[a]”意思是不超过a的最大整数，x就是平方根的整数部分的意思啦。
但是n是大数呀，不然就可以直接sqrt一下了，伤心。。。立马又想到JAVA的大数类，好开心，然后搜了一下
又懵逼了，JAVA大数类有加减乘除，唯独没有开根的函数，又好伤心，可恶的学长出这么恶心的题，明明算法想到了
却实现不出来。。
但是伤心是没有用的，终究还是要解决问题。自己动手写个求平方根的板吧。
写不来呀，那我来教你吧。
首先，平方根必然在[1,n]之间，那枚举呗，对于1<=i<=n，一旦发现i*i>n，那么i-1就是答案咯。
i是大数，i*i用高精度乘法就OK拉。不对，等等n可是等于10^100次方哦，枚举到死也不可能枚举得出来呀。
诶，有了，枚举慢，由于i*i具有单调性，那我二分嘛，这样不就快了？
嘿嘿，这才是正解。
继续耐心看吧，看总比写容易吧，我都写了这么多你都不愿意看，那你真是真是太懒了。
设len是数n的位数。那我们来计算下复杂度吧。
二分的次数就是log(2,10^len)=len*log(2,10),约等于3.3*len
对于每一次二分，还要调用高精度乘法，朴素高精度乘法就是o(len*len)
故总复杂度就是o(len*len*len)，len<=100
时限内就可以解决啦。
我的博客上有高精度开根的代码哦。
 C++代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int L=2015;
string add(string a,string b)//只限两个非负整数相加
{
    string ans;
    int na[L]={0},nb[L]={0};
    int la=a.size(),lb=b.size();
    for(int i=0;i<la;i++) na[la-1-i]=a[i]-'0';
    for(int i=0;i<lb;i++) nb[lb-1-i]=b[i]-'0';
    int lmax=la>lb?la:lb;
    for(int i=0;i<lmax;i++) na[i]+=nb[i],na[i+1]+=na[i]/10,na[i]%=10;
    if(na[lmax]) lmax++;
    for(int i=lmax-1;i>=0;i--) ans+=na[i]+'0';
    return ans;
}
string sub(string a,string b)//只限大的非负整数减小的非负整数
{
    string ans;
    int na[L]={0},nb[L]={0};
    int la=a.size(),lb=b.size();
    for(int i=0;i<la;i++) na[la-1-i]=a[i]-'0';
    for(int i=0;i<lb;i++) nb[lb-1-i]=b[i]-'0';
    int lmax=la>lb?la:lb;
    for(int i=0;i<lmax;i++)
    {
        na[i]-=nb[i];
        if(na[i]<0) na[i]+=10,na[i+1]--;
    }
    while(!na[--lmax]&&lmax>0)  ;lmax++;
    for(int i=lmax-1;i>=0;i--) ans+=na[i]+'0';
    return ans;
}
string mul(string a,string b)//高精度乘法a,b,均为非负整数
{
    string s;
    int na[L],nb[L],nc[L],La=a.size(),Lb=b.size();//na存储被乘数，nb存储乘数，nc存储积
    fill(na,na+L,0);fill(nb,nb+L,0);fill(nc,nc+L,0);//将na,nb,nc都置为0
    for(int i=La-1;i>=0;i--) na[La-i]=a[i]-'0';//将字符串表示的大整形数转成i整形数组表示的大整形数
    for(int i=Lb-1;i>=0;i--) nb[Lb-i]=b[i]-'0';
    for(int i=1;i<=La;i++)
        for(int j=1;j<=Lb;j++)
        nc[i+j-1]+=na[i]*nb[j];//a的第i位乘以b的第j位为积的第i+j-1位（先不考虑进位）
    for(int i=1;i<=La+Lb;i++)
        nc[i+1]+=nc[i]/10,nc[i]%=10;//统一处理进位
    if(nc[La+Lb]) s+=nc[La+Lb]+'0';//判断第i+j位上的数字是不是0
    for(int i=La+Lb-1;i>=1;i--)
        s+=nc[i]+'0';//将整形数组转成字符串
    return s;
}
int sub(int *a,int *b,int La,int Lb)
{
    if(La<Lb) return -1;//如果a小于b，则返回-1
    if(La==Lb)
    {
        for(int i=La-1;i>=0;i--)
            if(a[i]>b[i]) break;
            else if(a[i]<b[i]) return -1;//如果a小于b，则返回-1

    }
    for(int i=0;i<La;i++)//高精度减法
    {
        a[i]-=b[i];
        if(a[i]<0) a[i]+=10,a[i+1]--;
    }
    for(int i=La-1;i>=0;i--)
        if(a[i]) return i+1;//返回差的位数
    return 0;//返回差的位数

}
string div(string n1,string n2,int nn)//n1,n2是字符串表示的被除数，除数,nn是选择返回商还是余数
{
    string s,v;//s存商,v存余数
     int a[L],b[L],r[L],La=n1.size(),Lb=n2.size(),i,tp=La;//a，b是整形数组表示被除数，除数，tp保存被除数的长度
     fill(a,a+L,0);fill(b,b+L,0);fill(r,r+L,0);//数组元素都置为0
     for(i=La-1;i>=0;i--) a[La-1-i]=n1[i]-'0';
     for(i=Lb-1;i>=0;i--) b[Lb-1-i]=n2[i]-'0';
     if(La<Lb || (La==Lb && n1<n2)) {
            //cout<<0<<endl;
     return n1;}//如果a<b,则商为0，余数为被除数
     int t=La-Lb;//除被数和除数的位数之差
     for(int i=La-1;i>=0;i--)//将除数扩大10^t倍
        if(i>=t) b[i]=b[i-t];
        else b[i]=0;
     Lb=La;
     for(int j=0;j<=t;j++)
     {
         int temp;
         while((temp=sub(a,b+j,La,Lb-j))>=0)//如果被除数比除数大继续减
         {
             La=temp;
             r[t-j]++;
         }
     }
     for(i=0;i<L-10;i++) r[i+1]+=r[i]/10,r[i]%=10;//统一处理进位
     while(!r[i]) i--;//将整形数组表示的商转化成字符串表示的
     while(i>=0) s+=r[i--]+'0';
     //cout<<s<<endl;
     i=tp;
     while(!a[i]) i--;//将整形数组表示的余数转化成字符串表示的</span>
     while(i>=0) v+=a[i--]+'0';
     if(v.empty()) v="0";
     //cout<<v<<endl;
     if(nn==1) return s;
     if(nn==2) return v;
}
bool cmp(string a,string b)
{
    if(a.size()<b.size()) return 1;//a小于等于b返回真
    if(a.size()==b.size()&&a<=b) return 1;
    return 0;
}
string BigInterSqrt(string n)
{
    string l="1",r=n,mid,ans;
    while(cmp(l,r))
    {
        mid=div(add(l,r),"2",1);
        if(cmp(mul(mid,mid),n)) ans=mid,l=add(mid,"1");
        else r=sub(mid,"1");
    }
    return ans;
}
string DeletePreZero(string s)
{
    int i;
    for(i=0;i<s.size();i++)
        if(s[i]!='0') break;
    return s.substr(i);
}
int main()
{
     //freopen("in.txt","r",stdin);
   //  freopen("out.txt","w",stdout);
    string n;
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n;
        n=DeletePreZero(n);//去除前导0
        string sqrt_n=BigInterSqrt(n);//求出平方根的整数部分
        cout<<sqrt_n<<endl;
        //cout<<BigInterSqrt(n).size()<<endl;
    }
    return 0;
}

JAVA版

import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
	static Scanner cin = new Scanner (new BufferedInputStream(System.in));
	public static BigInteger BigIntegerSqrt(BigInteger n){
		BigInteger l=BigInteger.ONE,r=n,mid,ans=BigInteger.ONE;
		while(l.compareTo(r)<=0){
			mid=l.add(r).divide(BigInteger.valueOf(2));
			if(mid.multiply(mid).compareTo(n)<=0){
				ans=mid;
				l=mid.add(BigInteger.ONE);
			}else{
				r=mid.subtract(BigInteger.ONE);
			}
		}
		return ans;
	}
	public static void main(String args []){
		BigInteger n;
		int t;
		t= cin.nextInt();
		while(t > 0)
		{
			t--;
			n=cin.nextBigInteger();
			BigInteger ans=BigIntegerSqrt(n);
			System.out.println(ans);
		}
	}
}

1006

首先看到数据量，直接DFS暴力肯定是不行的。
注意到m<=10，可以想到状态压缩DP。
其实状态压缩DP本身也算是一种暴力方法。
设dp[i][j]表示前i行状态为j时能取得的最大值。
则状态转移方程为：dp[i][j]=max(dp[i-1][k])+第i行状态j所取数之和，其中j为第i行的状态,k为i-1行的状态。
因为并不知道下一行取最优值时对应的是当前行的哪一个状态，所以必须把当前行所有状态都保存下来。
当求出dp[n][i]时，求出了第i行所有状态对应的最优解，那只要取这之中最大的最优解即可。
事实上方格取数这类题不是状态DP就是成网络流。
此题属于比较简单的状态压缩题了。
下面分析复杂度：
枚举行需要n次  
  对于第当前行，要枚举所有状态，最多有2^k种状态
    对于第i行的每一种状态，需要枚举上一行所有状态
故复杂度为O(n*2^k*2^k)
n=100,m=10,k=10的极端情况下，可能会超时，但复杂度也差不多在时限可以接受的量级，不妨一试。
 

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=105,maxm=11;
int a[maxn][maxm],dp[maxn][1<<maxm];
int n,m,k,top;
int s[1<<maxm];
int CountOne(int n)//计算1的个数
{
    int ans=0;
    while(n) ans++,n&=n-1;
    return ans;
}
int GetSum(int i,int n)//计算出某个状态对应的和
{
    int ans=0;
    for(int j=0;j<m;j++)
        if(n>>j&1) ans+=a[i][j];
    return ans;
}
void init()//预处理出合法状态
{
    top=0;
    for(int i=0;i<(1<<m);i++)
        if(CountOne(i)<=k) s[top++]=i;
}
void input()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        scanf("%d",&a[i][j]);
}
void solve()
{
    init();//枚举所有状态
    for(int i=0;i<top;i++)//初始化边界
        dp[0][s[i]]=GetSum(0,s[i]);
    for(int i=1;i<n;i++)//枚举第i行
    {
        for(int j=0;j<top;j++)//枚举第i行的所有状态
        {
            int Max=-1;
            for(int p=0;p<top;p++)//枚举第i-1行的所有状态
            {
                if(s[p]&s[j]) continue;
                Max=max(Max,dp[i-1][p]);
            }
            dp[i][s[j]]=Max+GetSum(i,s[j]);
        }
    }
    int ans=-1;
    for(int i=0;i<top;i++)
        ans=max(ans,dp[n-1][s[i]]);
    printf("%d\n",ans);
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        input();//读取数据
        solve();//状态压缩DP
    }
    return 0;
}

1007

DFS暴力
注意马鳖脚的情况
复杂度无法估计

#include<cstdio>
const int maxn=10;
int n,m,k,ans;
char a[maxn][maxn];
int dir[8][2]={{1,-2},{-1,-2},{-2,-1},{-2,1},{-1,2},{1,2},{2,1},{2,-1}};//马走的方向
int dir1[4][2]={{0,-1},{-1,0},{0,1},{1,0}};//憋马脚的四个方向
bool ok(int nx,int ny)
{
    if(0<=nx&&nx<n&&0<=ny&&ny<m) return 1;
    return 0;
}
bool judge(int x,int y)
{
    for(int i=0;i<8;i++)//枚举马能到达的所有地方判断是否有冲突
    {
        int nx=x+dir[i][0],ny=y+dir[i][1];
        int tx=x+dir1[i/2][0],ty=y+dir1[i/2][1];
        if(ok(nx,ny))//判断坐标是否越界
        {
            //如果能一步到达的位置有马且不憋足则有冲突
            if(a[nx][ny]=='#'&&a[tx][ty]=='.') return 0;
        }
    }
    return 1;
}
bool judge1()
{
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        if(a[i][j]=='#')
        {
            if(judge(i,j)==0) return 0;
        }
    return 1;
}
void dfs(int d,int cnt)
{
    //puts("Yes");
    if(k==cnt)//填满了k个，则到达目标状态
    {
        if(judge1())
        {
            ans++;
            //for(int i=0;i<n;i++) puts(a[i]);
        }
        return ;
    }
    if(d==n*m) return ;//填满了所有格子了
    int x=d/m,y=d%m;//解码

    if(a[x][y]=='.')
    {
        a[x][y]='#';//放置
        dfs(d+1,cnt+1);
        a[x][y]='.';//回溯
    }
    dfs(d+1,cnt);//不放置
}
int main()
{
    int t;
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&n,&m,&k);
        for(int i=0;i<n;i++)
            scanf("%s",a[i]);
        ans=0;
        dfs(0,0);
        printf("%d\n",ans);
    }
    return 0;
}

1008

#include<cstdio>
#include<cstring>
const int maxn=200005;
char s[maxn],ans[maxn];
int main()
{
    int t;
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s",s);
        int p=0,len=strlen(s);
        for(int i=0,k=0;i<len;i++)
        {
            if(s[i]=='1') k++;
            else k=0;
            ans[p++]=s[i];
            if(k==5) ans[p++]='0',k=0;
        }
        ans[p]='\0';
        //printf("%d\n",strlen(ans));
        printf("01111110%s01111110\n",ans);
    }
    return 0;
}