url: http://oj.ecustacm.cn/problem.php?id=1369

tag:
模拟

思路：
求字节的二进制表示，其实就是求每个数的补码。对于正数来说，补码就是原码。对于负数来说，先是对原码求反码然后再加1.对于-128来说比较特殊，补码是10000000，通过正常的求法求不出，所以需要特殊判断。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
int num[10];

void resoult(int a)
{
    int j = 8;
    while(a)
    {
        num[j --] = a % 2;
        a /= 2;
    }
}
void inverse()
{
    for (int i = 2; i <= 8; i ++)
    {
        if (num[i] == 0) num[i] = 1;
        else num[i] = 0;
    }
    num[8] += 1;
    for (int i = 8; i >= 3; i --)
    {
        num[i - 1] += num[i] / 2;
        num[i] %= 2;
    }
}
void binary(int a)
{
    if (a == -128)
    {
        cout << "1 " << endl;
        return;
    }
    memset(num, 0, sizeof num);
    if (a >= 0)
    {
        num[1] = 0;
        resoult(a);
    }
    else
    {
        num[1] = 1;
        resoult(abs(a));
        inverse();
    }
}
void print()
{
    for (int i = 1; i <= 8; i ++)
    {
        if (num[i]) cout << 1;
        else cout << ' ';
    }
}
int main()
{
    for (int i = 0; i < 10; i ++)
    {
        for (int j = 0; j < 16; j ++)
        {
            int a, b;
            cin >> a >> b;
            binary(a);
            print();
            binary(b);
            print();
            cout << endl;
        }
        cout << endl;
    }
    return 0;
}

简洁版：

#include <iostream>
#include<cstring>
using namespace std;
int num[10];
void print()
{
    
    for(int i=1;i<=8;i++) printf("%c",num[i]==1?"1":" ");
}
int main()
{
    
    int a,b;
    for(int i=1;i<=10;i++)
    {
    
        for(int j=1;j<=16;j++)
        {
    
            cin>>a>>b;
            memset(num,0,sizeof(num ));
            for(int k =8;k>=1;i--) num[k]&=a,a>>=1;
            print();
             memset(num,0,sizeof(num ));
            for(int k =8;k>=1;k--) num[k]&=b,b>>=1;
            print();
            cout<<endl;
        }
        cout<<endl;
    }
    return 0;
}

结果：

     1
     1
     1    1
111111111111
     1    1
     1    1
     1    1
     1    1
     1    1
    1     1
    1     1
   1      1   1
   1      1   1
  1        1111
11

   1     1
   1     1
  1   1  1   1
 1111111 111111
 1    1 1    1
 1    11     1
 1    1      1
 1    1 1    1
 111111  11  1
 1    1   1  1
 1    1      1
 1    1      1
 1    1      1
 111111      1
 1    1   1 1
           1

     1
     1
     1
     1    1
111111111111
     1    1
     1    1
     1    1
     1    1
     1    1
    1     1
    1     1
   1      1   1
   1      1   1
  1        1111
11

        1

 1      1
 1
  11    1
  11
   1   1    1
       1111111
      1     1
    1    1 1
   1     1
  1      1
111      1
  1     1 1
  1     1 1
  1    1   1
  1   1     1
  1  1      111
  1 1        1

     1
      11
       1
             1
111111111111111
     1
     1     1
     11111111
     1     1
     1     1
     1     1
    1      1
    1      1
   1       1
  1     1 1
 1       1

   1     1
   1 1   1  1
  11111 111111
 1  1  1  1
     1 1   1
       1
  11111111111
       1
111111111111111
         1
         1 1
  11111111111
    1    1
     1   1
       1 1
        1


           1
  11111111111
       1
       1
       1
       1     1
111111111111111
       1
       1
       1
       1
       1
       1
       1
     1 1
      1

      1
      1
     1111111
    1     1
   11    1
  1  1 11
  1  1 1
      1 1
      1
    11  1
    11
 111   1111111
      1     1
    11     1
   1  1   1
  1    111
       1
    111
 111

       1
       1
       1
    1  1  1
    1  1   1
   1   1    11
   1   1     1
  1    1   1
 1     1   1
       1  1
       1 1
        1

       1
      1
    11
 111




     1111111
   11      11
  11        11
  111       11
          111
        111
        11
        1



       11
       1
      1111
       11
       1

答案：

#include <iostream>
#include <cmath>
#include <cstdio>
using namespace std;
int main()
{
    printf("%.0f", pow(9, 9));
    return 0;
}

url: https://www.luogu.com.cn/problem/P4095

tag:
动态规划，背包DP，进制，枚举

思路：
多重背包问题为基础，做两次01背包，前一次后一次，之后对于每次询问的id就跳过那个id求可能的最大值。

代码：

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#include <algorithm>  
using namespace std;  
typedef long long LL;  
const int N = 100010;  
struct node{  
    int id;LL s;  
}w[N], v[N];  
LL f1[N][1010], f2[N][1010];  
int idx, m, n;  
int main()  
{  
    cin >> n;  
    for (int i = 1; i <= n;  i++)  
    {  
        int cw, cv, c;  
        cin >> cw >> cv >> c;  
        int now = 1;  
        while (now <= c)  
        {  
            w[++idx].s = cw * now, v[idx].s = cv * now;  
            w[idx].id = i, v[idx].id = i;  
            c -= now, now *= 2;  
        }  
        if(c) {  
            w[++idx].s = cw * c, v[idx].s = cv * c;  
            w[idx].id = i, v[idx].id = i;  
        }  
    }  
    cin >> m;  
    n = idx;  
    for (int i = 1; i <= n; i ++)  
    {  
        for (int j = 0; j <= 1000; j ++) f1[i][j] = f1[i - 1][j];  
        for (int j = 1000; j >= w[i].s; j --)  
        {  
            f1[i][j] = max(f1[i][j], f1[i - 1][j - w[i].s] + v[i].s);  
        }  
    }  
    for (int i = n; i >= 1; i --)  
    {  
        for (int j = 0; j <= 1000; j ++) f2[i][j] = f2[i + 1][j];  
        for (int j = 1000; j >= w[i].s; j --)  
        {  
            f2[i][j] = max(f2[i][j], f2[i + 1][j - w[i].s] + v[i].s);  
        }  
    }  
    for (int k = 1; k <= m; k ++)  
    {  
        int cn, V;  
        cin >> cn >> V;  
        cn ++;  
        LL ans = 0;  
        int l = 0, r = 0;  
        while (w[l + 1].id < cn && l < n) ++ l;  
        r = l;  
        while (w[r + 1].id <= cn && r < n) ++ r;  
        for (int j = 0; j <= V; j++)  
        {  
            ans = max(ans, f1[l][j] + f2[r + 1][V - j]);  
        }  
        cout << ans << endl;  
    }  
    return 0;  
}

url: http://oj.ecustacm.cn/problem.php?id=1361

tag:
数学

思路：
计算末尾零可以求每个因子中有多少对因子5和因子2，因为2 * 5 = 10，又因为2出现的次数会比5多，因为只要是偶数的情况就会出现因子2.所以只要计算这100个数中，每个数中因子5的个数，然后累加最后输出即可。

对于求阶乘来说，如果是某个数的阶乘，求这个数除以5，25，125……5^k之后累加。例如100除以5之后等于20，那么对于1到20来说每个数乘以5后都会变成一个贡献5因子的数，除以25之后等于4说明1到4中每个数乘25都可以变成一个贡献25因子的数，而25 = 5 5，则是在原来贡献了5因子基础上多贡献一个5，为了避免重复，以及避免漏算，只需要将4 加上 20，即为答案。说明对于100！（1 2 3 …… * 100）来说，一共可以贡献出24个因子5，就是有24个末尾0.这种求阶乘末尾0的方式实际上和本题有出路。

代码：

// 乘积尾零
#include <iostream>
using namespace std;
int main()
{
    int n = 10;
    int cnt = 0;
    for (int i = 0; i < n; i ++)
    {
        for (int j = 0; j < n; j ++)
        {
            int a;
            cin >> a;
            while (a && a % 5 == 0)
            {
                if (a % 5 == 0)
                {
                    a /= 5;
                    cnt ++;
                }
            }
        }
    }
    cout << cnt << endl;
    return 0;
}

答案：

#include <iostream>
using namespace std;
int main()
{
    cout << 31 << endl;
    return 0;
}

问题描述

小C在学习二进制运算，他了解到每个非负整数都有其二进制表示。例如，整数 5 可以被表示为二进制 "101"，整数 11 可以被表示为二进制 "1011"，并且除了 N = 0 外，任何二进制表示中都不含前导零。

二进制的反码表示是将每个 1 变为 0，每个 0 变为 1。例如，二进制数 "101" 的二进制反码为 "010"。现在小C想知道，给定一个十进制数 N，它的二进制反码对应的十进制数是多少。

测试样例

样例1：

输入：N = 5
输出：2

样例2：

输入：N = 10
输出：5

样例3：

输入：N = 0
输出：1

代码：

int solution(int N) {
    if (N == 0) {
        return 1;
    }
    int bits = std::log2(N) + 1;
    std::bitset<32> binary(N);
    std::bitset<32> inverted = ~binary;
    int result = (inverted.to_ulong() & ((1 << bits) - 1));
    return result;
}

解释

• std::log2(N) + 1:

  • 计算 N 的二进制位数。

• std::bitset<32> binary(N);:

  • 这行代码将整数 N 转换为一个 32 位的二进制表示。

• std::bitset<32> inverted = ~binary;:

  • 这行代码对 binary 进行按位取反操作，得到 inverted。

• int result = inverted.to_ulong();:

  • 这行代码将 inverted 转换回无符号长整型。

• (1 << bits) - 1:

  • 生成一个掩码，只保留低 bits 位。

• inverted.to_ulong() & ((1 << bits) - 1):

  • 只取 inverted 的低 bits 位，忽略高位部分。

url: http://oj.ecustacm.cn/problem.php?id=1370

tag:
动态规划

思路：
使用动态规划的思想，令 f[i][j] 表示在i层楼内，使用j部手机，在使用最佳策略下，最多的测试次数，换句话说就是在i层楼内，使用j部手机最少需要花费的最大的测试次数。对于只有1部手机的情况来说，有几层就要测试几次。对于0层来说，不管几部手机都是0次。因为不知道从那一层开始掉落可以得到最优的答案，所以可以枚举对于每一个i都枚举从1开始到i层，表示从第k层开始掉落得到的结果。而对于每一个k来说，需要取一个最大值一共只有两种情况一种是摔坏，那么可以是 dp[k - 1][j - 1] 表示从k - 1层内用j - 1部手机测试次数，如果没有摔坏就是 dp[i - k][j] 即，剩余的i - k层内使用j部手机测试次数，之后两者取max再加上第k层的1次，对每种k的结果取min就是最后答案。最后输出 dp[1000][3] 表示1000层内，3部手机测试次数。

代码：

// 测试次数
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n = 1000;
int dp[1001][4];
int main()
{
    memset(dp, 0x3f, sizeof dp);
    for (int i = 1; i <= n; i ++) dp[i][1] = i;
    for (int i = 1; i <= 3; i ++) dp[0][i] = 0;
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= 3; j ++)
            for (int k = 1; k <= i; k ++)
                dp[i][j] = min(dp[i][j], max(dp[k - 1][j - 1], dp[i - k][j]) + 1);
    cout << dp[1000][3];
    return 0;
}