51nod二级算法题全部题解

首先对二级算法做一个总结吧，大体上都是一些不是很难的题，但是很有助于提高的，毕竟对于我这样的萌新来说。既然题已经刷完了，当然还是写一篇总结，对学到的经验进行一下总结。。。不然下次碰到不会的还是不会就很尴尬了。

下面进入正文：

1873 初中的算术：

就是大数运算，如果想写的同学可以用C++去写写，也不是很难就是麻烦点，就当是练手了，这方面的博客很多直接百度就好了。这里笔者比较懒就直接用Java暴力过了。。。Java大法好啊。

import java.math.BigDecimal;import java.util.*;public class MAIN {    public static void main(String args[])    {        Scanner cin = new Scanner(System.in);        double m = cin.nextDouble();        int n = cin.nextInt();        BigDecimal ans=new BigDecimal("1");        for(int i = 0; i < n; i++)            ans = ans.multiply(BigDecimal.valueOf(m));        String s=ans.stripTrailingZeros().toPlainString();        int i=0;        if(s.charAt(0)=='0'&&s.charAt(1)=='.')            i=1;        for(;i<s.length();i++)            System.out.print(s.charAt(i));    }}

1596 搬货物问题：

二进制的重要性，存0-1e6的这些指数的出现次数，然后不停的除2进位就可以，从低位开始，只要是留下的某一位进不上去剩下一个了，那就是一定要花费一次机会去运送这个。需要注意的是：1，题中输入的货物的2^wi的wi不是货物的重量；2，数组最大要开大点，后面可能会进好几次超过1e6.

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>using namespace std;typedef long long ll;const int Max = 1000024;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;int n;ll arr[Max];int main( ){    //freopen("input.txt", "r", stdin);    while(~scanf("%d", &n))    {        memset(arr, 0, sizeof(arr));        for(int i=0; i<n; i++)        {            int t;            scanf("%d", &t);            arr[t]++;        }        int ans = 0;        for(int i=0; i<Max; i++)        {            arr[i+1] += arr[i]/2;            arr[i] %= 2;            if(arr[i] == 1)                ans++;        }        cout<<ans<<endl;    }    return 0;}

1521 一维战舰：

核心就是每次失去一个可用位置k，对于整个区间的影响。也就是只需要计算出来k位于的区间[l, r]本来的可容纳战舰数再减去k被占据之后，可容纳的战舰数。有点像莫对算法里的区间转移的问题。解决了这个就按题意模拟就行了

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>using namespace std;typedef long long ll;const int Max = 1e6+5;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;int n, k, a;ll arr[Max];int main( ){    //freopen("input.txt", "r", stdin);    while(~scanf("%d%d%d", &n,&k,&a))    {        memset(arr, 0, sizeof(arr));        int m;        scanf("%d", &m);        int ans = 0;        int MaxNum = (n+1)/(a+1);        for(int i=1; i<=m; i++)        {            int t, prenum, curnum;//分区间之前能容纳的战舰数，分区间之后能容纳的战舰数            scanf("%d", &t);            if(ans)                continue;            arr[t] = 1;            int left=t-1, right=t+1;            while(left>=1 && arr[left]==0)                left--;            while(right<=n && arr[right]==0)                right++;            prenum = (right-left)/(a+1);            curnum = (t-left)/(a+1)+(right-t)/(a+1);            MaxNum -= prenum - curnum;            if(MaxNum<k && ans==0)                ans = i;        }        if(ans)            cout<<ans<<endl;        else            cout<<-1<<endl;    }    return 0;}

1489 蜥蜴和地下室：

dfs，这个没啥好说的，就是多练练吧，数据量很小，dfs就好了

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>using namespace std;typedef long long ll;const int Max = 1e6+5;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;int n, a, b, ans;int arr[Max];void dfs(int x, int num)//第x个弓箭手，当前的已使用火球数为num{    if(x == n-1)    {        int t1 = arr[x-1]/a+1;        int t2 = arr[x]/b+1;        if(arr[x-1]<0)            t1 = 0;        if(arr[x]<0)            t2 = 0;        num += max(t1, t2);        ans = min(ans, num);        return;    }    if(num>ans)        return;    int pre = arr[x-1]/b+1;    if(arr[x-1] < 0)        pre = 0;    int cur = arr[x]/a+1;    if(arr[x] < 0)        cur = 0;    cur = max(cur, pre);//在这里必须保证把x-1位置的弓箭手杀死    for(int i=pre; i<=cur; i++)    {        arr[x+1] -= b*i;        arr[x] -= a*i;        dfs(x+1, num+i);        arr[x+1] += b*i;        arr[x] += a*i;    }}int main( ){    //freopen("input.txt", "r", stdin);    while(~scanf("%d%d%d", &n,&a,&b))    {        ans = INF;        for(int i=0; i<n; i++)            scanf("%d", arr+i);        dfs(1, 0);        cout<<ans<<endl;    }    return 0;}

1629 B君的圆锥：

数学问题，自己动笔算吧

1433 0和5：

找规律问题，被9整除和5的个数是有关系的，算几组就可以了

1413 权势二进制：

找规律问题，这个很好想。就是所有位中的最大数字。

1432 独木舟：

很容易想的贪心，尽量将最重的和最轻的一起匹配，这样的浪费是最小的，自然是最优的。在对数据的顺序不做要求的时候，排序经常是一种有效的手段，能让问题简单不少。

1428 活动安排问题：

贪心+1 ， 每次贪心的选择最先开始的活动，如果此时教室已经不够用，那么就需要再开一个。实际生活中也是这样的。

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>using namespace std;typedef long long ll;const int Max = 1e6+5;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;const ll llINF = 1e18;int n, m;pair<ll, ll> arr[Max];ll heap[Max];bool cmp(pair<ll, ll> a, pair<ll ,ll> b){    if(a.first != b.first)        return a.first<b.first;    return a.second<b.second;}bool cmp1(int a, int b){    return a>b;}int main( ){    //freopen("input.txt", "r", stdin);    while(~scanf("%d", &n))    {        int ans = 0, cnt = 0;        heap[0] = llINF;        for(int i=0; i<n; i++)            scanf("%lld%lld", &arr[i].first, &arr[i].second);        sort(arr, arr+n, cmp);        for(int i=0; i<n; i++)        {            if(arr[i].first < heap[0])            {                heap[cnt++] = arr[i].second;                make_heap(heap, heap+cnt, cmp1);                ans++;            }            else            {                heap[0] = arr[i].second;                make_heap(heap, heap+cnt, cmp1);            }        }        cout<<ans<<endl;    }    return 0;}

1417 天堂里的游戏：

好像也是一个找规律的题。

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>using namespace std;typedef long long ll;const int Max = 1e6+5;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;const ll llINF = 1e18;int n, m;ll Gcd(ll a,ll b){    ll t = min(a, b);    a = max(a, b);    b = t;    while( a%b )    {        t = b;        b = a%b;        a = t;    }    return b;}int main( ){    //freopen("input.txt", "r", stdin);    int T;    cin>>T;    while(T--)    {        ll a,b;        scanf("%lld%lld", &a,&b);        ll A = a+3*b;        ll B = 4*(a+b);        ll gcd = Gcd(A, B);        cout<<A/gcd<<"/"<<B/gcd<<endl;    }    return 0;}

1315 合法整数集:

http://blog.csdn.net/xh413235699/article/details/72783711

1279 扔盘子

http://blog.csdn.net/xh413235699/article/details/72802196

1278 相离的圆

只需要将所有的圆的左位置进行记录，并进行排序，然后对于每一个圆我们都统计在他右边相离的圆的个数，只需要二分找到那个临界点就好了。而且这样统计下来并不会重复统计。因为我们是单方向统计的，很多时候单方向的计数都可以避免重复计数的问题。

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>#include<stack>using namespace std;typedef long long ll;const int Max = 1e5+5;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;const ll llINF = 1e18;int n;int arr[Max], p[Max], r[Max];int main( ){    //freopen("input.txt", "r", stdin);    while(cin>>n)    {        int ans = 0;        for(int i=0; i<n; i++)        {            scanf("%d%d", p+i, r+i);            arr[i] = p[i]-r[i];        }        sort(arr, arr+n);        for(int i=0; i<n; i++)        {            int k = upper_bound(arr, arr+n, p[i]+r[i])-arr;//刚好相离的那个圆的序号            ans += (n-k);        }        cout<<ans<<endl;    }    return 0;}

1266 蚂蚁：

最短时间很显然，主要是最长时间，这里就考验大家的分析能力了，仔细想想其实，那个碰头之后互相反向，其实可以等价为两个蚂蚁都是继续走自己的路，也就是说这个反向根本没用。是用来干扰我们理清问题的思路的。（可以这么想，两个蚂蚁碰头之后，他们处于同一个位置，也就是可以认为它们是同一个蚂蚁，那么这两个蚂蚁是没有区别的，只需要让每一个蚂蚁保持原来的行走方向就可以了，那么最大值就是max（x， l-x））.其实每次折返的过程可以看作两个蚂蚁互换了角色的过程，举个例子自己画画图比较好理解。

1138连续整数问题：

http://blog.csdn.net/xh413235699/article/details/72808736

1133 不重叠的线段：

贪心，优先选择左端点小的线段。

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>#include<stack>using namespace std;typedef long long ll;const int Max = 1e5+5;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;const ll llINF = 1e18;struct xianduan{    int start, finish;};int n;xianduan arr[Max];bool cmp(const xianduan& a, const xianduan& b){    if(a.finish != b.finish)        return a.finish<b.finish;    return a.start < b.start;}int main( ){    //freopen("input.txt", "r", stdin);    while(cin>>n)    {        for(int i=0; i<n; i++)            scanf("%d%d", &arr[i].start, &arr[i].finish);        sort(arr, arr+n, cmp);        int ans = 0, currentend = -(1e9+5);        for(int i=0; i<n; i++)        {            if(arr[i].start >= currentend)            {                ans++;                currentend = arr[i].finish;            }        }        cout<<ans<<endl;    }    return 0;}

1126 求递推序列的第n项：

转化递推公式为矩阵相乘的形式，这样可以利用矩阵的性质，先对矩阵的乘积进行计算，然后这里就可以使用矩阵快速幂算法O(logn)。算是一类型题吧，记下。

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>#include<stack>using namespace std;typedef long long ll;const int Max = 1e5+5;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;const ll llINF = 1e18;struct matrix{    int arr[2][2];    matrix( )    {        arr[0][0] = 1; arr[0][1] = 0;        arr[1][0] = 0; arr[1][1] = 1;    }    void print( )    {        for(int i=0; i<2; i++)        {            for(int j=0; j<2; j++)                cout<<arr[i][j]<<" ";            cout<<endl;        }    }};int n, a, b;void init(matrix& ans) //初始化矩阵{    ans.arr[0][0] = a;    ans.arr[0][1] = b;    ans.arr[1][0] = 1;    ans.arr[1][1] = 0;}matrix cheng(const matrix& a, const matrix& b){    matrix answer;    answer.arr[0][0] = (a.arr[0][0]*b.arr[0][0]+a.arr[0][1]*b.arr[1][0])%7;    answer.arr[0][1] = (a.arr[0][0]*b.arr[0][1]+a.arr[0][1]*b.arr[1][1])%7;    answer.arr[1][0] = (a.arr[1][0]*b.arr[0][0]+a.arr[1][1]*b.arr[1][0])%7;    answer.arr[1][1] = (a.arr[1][0]*b.arr[0][1]+a.arr[1][1]*b.arr[1][1])%7;    return answer;}void msp(matrix& ans, int n){    matrix temp;//储存快速幂遗留的乘积    while(n/2)    {        if(n%2)            temp = cheng(temp, ans);        ans = cheng(ans, ans);        n /= 2;    }    ans = cheng(ans, temp);}int main( ){    //freopen("input.txt", "r", stdin);    matrix ans;    while(cin>>a>>b>>n)    {        if(n == 1 || n==2)        {            cout<<1<<endl;            continue;        }        init(ans);//初始化矩阵，将递推公式转化为矩阵形式        msp(ans, n-2);//对矩阵进行快速幂运算O(logN)的复杂度        //ans.print( );        int t = (ans.arr[0][0]+ans.arr[0][1]+7)%7;        cout<<t<<endl;    }    return 0;}

1119 机器人走方格：

http://blog.csdn.net/xh413235699/article/details/72859044

1095 Anigram单词：

互为Anigram的单词，出现的字母都是相同的，而且数量也相同。利用这点，对原始单词进行统计一遍，然后每一个单词按照字典序在排序一遍，最后查map，两个数量相减就是答案。

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>#include<stack>#include<queue>using namespace std;typedef long long ll;const int Max = 1e4+5;const int mod = 1e9+7;//是素数const int Hash = 10000;const int INF = 1<<30;const ll llINF = 1e18;int m,n;int main( ){    //freopen("input.txt", "r", stdin);    while(~scanf("%d", &n))    {        map<string, int> map1, map2;        char s[11];        for(int i=0; i<n; i++)        {            scanf("%s", s);            map1[s]++;            int length = strlen(s);            sort(s, s+length);            map2[s]++;        }        scanf("%d", &m);        while(m--)        {            char s[11];            scanf("%s", s);            int ans1 = map1[s];            int length = strlen(s);            sort(s, s+length);            int ans2 = map2[s];            cout<<ans2 - ans1<<endl;        }    }    return 0;}

1094 和为k的连续区间

没有什么复杂度的问题，就是一个map的灵活运用。（STL真的重要）

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>#include<stack>#include<queue>using namespace std;typedef long long ll;const int Max = 1e4+5;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;const ll llINF = 1e18;int n,k;ll arr[Max], sum[Max];int main( ){    //freopen("input.txt", "r", stdin);    while(~scanf("%d%d",&n,&k))    {        map<ll, bool> m;        sum[0] = 0;        for(int i=1; i<=n; i++)        {            scanf("%lld", arr+i);            sum[i] = sum[i-1]+arr[i];            m[sum[i]] = true;//标记这个前缀和是可达的        }        int flag = 1;        for(int i=0; i<=n && flag; i++)            if(m[sum[i]+k])//从i开始的前缀和与后面某一项的前缀和之差等于k                for(int j=i; j<=n; j++)                    if(sum[j] == sum[i]+k)                    {                        flag = 0;                        cout<<i+1<<" "<<j<<endl;                        break;                    }        if(flag)            cout<<"No Solution"<<endl;        m.clear( );    }    return 0;}

1092 回文字符串：

总长度减去最大公共子序列就是答案。所以就是一个最大公共子序列问题。动态规划。

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>#include<stack>#include<queue>using namespace std;typedef long long ll;const int maxn = 1005;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;const ll llINF = 1e18;string in;int dp[maxn][maxn];int main( ){    //freopen("input.txt", "r", stdin);    while(cin>>in)    {        string temp;        int n = in.length();        for(int i=0; i<n; i++)            temp.insert(i, 1, in[n-i-1]);        //dp[i][j]表示以i，j下标结尾的字符串的最长公共子串        dp[0][0] = dp[1][0] = dp[0][1] = 0;        for(int i=1; i<=n; i++)            for(int j=1; j<=n; j++)            {                if(in[i-1] == temp[j-1])                    dp[i][j] = dp[i-1][j-1] + 1;                else                    dp[i][j] = max(dp[i][j-1], dp[i-1][j]);            }        cout<<n-dp[n][n]<<endl;    }    return 0;}

1062 序列中最大的数：

预处理。

1067 Bash游戏：

找规律题，如果模7等于0或者2就是B赢，否则A赢。

1050 循环数组最大字段和：

http://blog.csdn.net/xh413235699/article/details/77837180

1042 数字0-9的数量：

http://blog.csdn.net/xh413235699/article/details/77886860

1031 骨牌覆盖：

找规律问题。好像是首项为1，2的斐波那契数列。

1007 正整数分组：

背包问题的变形。选择的部分和越接近sum/2则二者的差值就越小，也就是答案。只需要求解最接近sum/2的结果。

#include<stdio.h>  #include<climits>  #include<algorithm>  #include<stack>  #include<iostream>  #include<cmath>  #include<set>  #include<vector>  #include<map>  #include<queue>  #include<string.h>  using namespace std;  #define N 10010  int a[N];   int n;  int dp[N];  int  main(void)  {          while(scanf("%d",&n)!=EOF)       {         int sum=0;         for(int i=1;i<=n;i++)         {               cin>>a[i];               sum+=a[i];//挑选出一些数字，是的越靠近sum/2,那么就是背包问题了          }         memset(dp,0,sizeof(dp));         for(int i=1;i<=n;i++)         {               for(int j=sum/2;j>=a[i];j--)               {                   dp[j]=max(dp[j],dp[j-a[i]]+a[i]);               }         }         cout<<abs((sum-dp[sum/2])-dp[sum/2])<<endl;       }       return 0;  }  

1024 矩阵中不重复的元素：

取对数大法好，数据量完全可以枚举但是数据会溢出，这时候取对数就很有用了。

#include<iostream>#include<cstring>#include<math.h>#include<stdlib.h>#include<cstring>#include<cstdio>#include<utility>#include<algorithm>#include<map>#include<stack>#include<set>#include<queue>using namespace std;typedef long long ll;const int maxn = 1e6+5;const int mod = 1e9+7;const int Hash = 10000;const int INF = 1<<30;const ll llINF = 1e18+999;set<double> s;int main( ){    int a, b ,m ,n;    while(cin>>m>>n>>a>>b)    {        for(int i=a; i<a+n; i++)            for(int j=b; j<b+m; j++)            {                s.insert(1.0*j*log2(i));            }        cout<<s.size()<<endl;    }}

1014 X^2 Mod P：

水题，直接枚举就好。

1010 只包含因子2 3 5 的数：

http://blog.csdn.net/xh413235699/article/details/77898885

以上就是全部的51nod的二级算法题的题解了。总的来说虽然题不是很难，但是涉及的算法还是挺多的，常常回头看看，温故而知新。

其中大概涉及到：大数运算（这个有java的库可以用），二进制，dfs，数学问题（数学运算简化问题，除法取模，找规律），预处理，二分，贪心，矩阵快速幂，STL（stack，map，set），动态规划，取对数。

其中动态规划真的是很高深的东西，这下面还是可以分成好多类题。

算法者，贵在积累，深入浅出。