4.1日刷题

1. 独木桥
   解题思路：如果从高空往下看，衣服都一样的话就算他们相遇往相反方向去之后跟一直往一个方向跑没有区别。于是最短时间就是每一位在桥上的士兵从它的位置跑到终点的最小值最大。最长时间就是从在桥上的位置往终点跑的最大值最大。代码如下：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 5010,INF = 0x3f3f3f3f;
int L,n;
int a[N];
int main()
{
  cin>>L;
  cin>>n;
  for (int i = 0; i < n; i ++ ) cin>>a[i];
  sort(a,a+n);
  int mintime = 0,maxtime = 0;
  for (int i = 0; i < n; i ++ )
  {
     if(!a[i] || a[i] > L) continue;
     mintime = max(min(a[i],L+1-a[i]),mintime);
     maxtime = max(max(a[i],L+1-a[i]),maxtime);
  }
  cout<<mintime<<" "<<maxtime<<endl;
  return 0;
}

2. 三连击
   解题思路：从小到大枚举每一个有1-9中三个数组组成的数，然后判断这个数是否合法即可。

#include<bits/stdc++.h>
using namespace std;

int ans = 0;
bool st[10];
void fun(int x,int vis[])
{
    while(x)
    {
        vis[x%10]++;
        x/=10;
    }
}
bool check(int x)
{
    int vis[10];
    memset(vis,0,sizeof vis);
    fun(x,vis);
    fun(x*2,vis);
    fun(x*3,vis);
    for(int i=1;i<=9;i++)
    {
        if(!vis[i] || vis[i] > 1) return false;
    }
    return true;
}
void dfs(int idx,string str)
{
    if(idx == 3)
    {
        int st = stoi(str);
        //cout<<st<<endl;
        if(check(st))
        {
            cout<<st<<" "<<st*2<<" "<<st*3<<endl;
        }
        return;
    }
    for (int i = 1; i <= 9; i ++ )
    {
        if(!st[i])
        {
            st[i] = true;
            char c = i+'0';
            dfs(idx+1,str+c);
            st[i] = false;
        }
    }
}
int main()
{
    dfs(0,"");
    return 0;
}

3. 阶乘之和
   解题思路： 需要用到高精度乘法和高精度加法，模板题

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;
int n;
vector<int> mul(vector<int> A,int b)
{
    reverse(A.begin(),A.end());
    vector<int> C;
    int t = 0;
    int len = A.size();
    for (int i = 0; i < len || t; i ++ )
    {
        if(i < len) t = A[i]*b+t;
        C.push_back(t%10);
        t/=10;
    }
    while(C.size() > 1 && C.back() == 0) C.pop_back();
    reverse(C.begin(),C.end());
    return C;
}
vector<int> fun(int x)
{
    vector<int> tmp;
    tmp.push_back(1);
    for (int i = 1; i <= x; i ++ )
    {
        tmp = mul(tmp,i);
    }
    return tmp;
}
vector<int> add(vector<int> A , vector<int> B)
{
    reverse(A.begin(),A.end());
    reverse(B.begin(),B.end());
    
    vector<int> C;
    int t = 0;
    int lena = A.size(),lenb = B.size();
    for (int i = 0; i < lena || i < lenb; i ++)
    {
        if(i < lena) t+=A[i];
        if(i < lenb) t+=B[i];
        C.push_back(t%10);
        t/=10;
    }
    while(C.size() > 1 && C.back() == 0) C.pop_back();
    reverse(C.begin(),C.end());
    return C;
}
int main()
{
    cin>>n;
    vector<int> ans,tmp;
    
    for(int i = 1;i<=n;i++)
    {
        tmp = fun(i); // 计算i的阶乘
        ans = add(ans,tmp); //计算之和
    }
    for(auto x : ans)
    {
        cout << x;
    }
    return 0;
}

5. 车站
   解题思路：运用递归进行求解，枚举每一个从第二个车站上车的人假设为t，可以递归求解出第n-1个车站开出的时候的人数，判断当前t是否满足题意，注意特判第n个车站开出时为0.

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 25,M = 2e4+10;
int a,n,m,x;
int t;//第二个车站的上车人数
int f(int i)
{
    if(i == 1) return a;
    if(i == 2) return t;
    return f(i-1) + f(i-2);
}
int g(int i)
{
    if(i == 1 || i == 2) return a;
    return g(i-1) + f(i-2);
}
int main()
{
    cin>>a>>n>>m>>x;
    if(x == 1 || x == 2) cout<<a<<endl;
    else if(x == n-1) cout<<m<<endl;
    else if(x == n) cout<<0<<endl;
    else
    {
        for (int i = 0; i < M; i ++ )
        {
            t = i;
            if(g(n-1) == m)
            {
                cout<<g(x)<<endl;
                break;
            }
        }
    }
    return 0;
}

6. P1012.拼数
   解题思路：这个题用到了字符串排序的cmp函数的编写，排序之和的字符串的顺序应该满足 s_i+s_j > s_j+s_i，i < j，cmp函数里面的式子满足的条件就是排完序之和满足的条件，例如 return a > b，就是前一个数要大于后一个数。代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N = 25;
string a[N];
int n;
bool cmp(string &s1,string &s2)
{
    if(s1+s2 > s2 + s1) return true;
    return false;
}
int main()
{
    cin>>n;
    int x;
    stringstream s;
    string str;
    for(int i=0;i<n;i++)
    {
        cin>>x;
        a[i] = to_string(x);
    }
    sort(a,a+n,cmp);
    for (int i = 0; i < n; i ++ ) cout<<a[i];
    return 0;
}

7. 完美矩阵
   解题思路：要变成完美矩阵满足这个条件:
   1 2
   3 4
   像这样的四个角上的元素相同，就一定满足回文
   为了减少讨论边是奇数还是偶数，可以用set来存储四个点，会有自动去重的功能
   最少的步数就是每个点变成其中位数的步数。

/*
要变成完美矩阵满足这个条件:
1   2


3   4
像这样的四个角上的元素相同，就一定满足回文
为了减少讨论边是奇数还是偶数，可以用set来存储四个点，会有自动去重的功能
最少的步数就是每个点变成其中位数的步数
*/
#include <iostream>
#include <cstring>
#include <algorithm>
#include <set>
using namespace std;
const int N = 110;
typedef long long LL;
typedef pair<int, int> PII;

int n,m;
int w[N][N];
LL cacl(set<PII> st)
{
    vector<int> q;
    for(auto s : st) q.push_back(w[s.first][s.second]);
    sort(q.begin(),q.end());
    LL sum = 0;
    int mid = q[q.size()/2];
    for(auto x : q)
    {
        sum+=abs(x - mid);
    }
    return sum;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n>>m;
        for (int i = 0; i < n; i ++ )
        {
            for (int j = 0; j < m; j ++ )
                cin>>w[i][j];
        }
        // 枚举左上部分就行
        LL res = 0;
        for (int i = 0; i <= n-i-1; i ++ )
        {
            for (int j = 0; j <= m-j-1; j ++ )
            {
                res+=cacl({{i,j},{i,m-j-1},{n-i-1,j},{n-i-1,m-j-1}});
            }
        }
        cout<<res<<endl;
        
    }
    return 0;
}

9. 子矩阵计数
   解题思路：
   明白概念：
   C[i][j] = 1要满足A[i]和B[i]都是1
   面积为k,枚举以下长和宽 假设a*b = k;
   现在问题就转化为了求A中有多少长度为a的连续的1，同理对B
   解决问题3的办法为枚举数列中右端点，如果为1，就找到它左边的第一个1，假设长度为t，那么将长度为1-t的所有情况都要+1，这时就用差分来进行处理 （差分的极致应用）

/*
明白概念：
10. C[i][j] = 1要满足A[i]和B[i]都是1
11. 面积为k,枚举以下长和宽 假设a*b = k;
12. 现在问题就转化为了求A中有多少长度为a的连续的1，同理对B
13. 解决问题3的办法为枚举数列中右端点，如果为1，就找到它左边的第一个1，假设长度为t，
  那么将长度为1-t的所有情况都要+1，这时就用差分来进行处理
*/
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 4e4+10;
int n,m,k;
int A[N],B[N];
int s1[N],s2[N];
void work(int w[],int s[],int n)
{
   int j = 0;
   for (int i = 1; i <= n; i ++ )
   {
       if(w[i])
       {
           j++;
           s[1]+=1;
           s[j+1]-=1;
       }
       else j = 0;
   }
   for (int i = 1; i <= n; i ++ )
   {
       s[i] += s[i-1];
   }
}
int main()
{
   cin>>n>>m>>k;
   for (int i = 1; i <= n; i ++ ) cin>>A[i];
   for (int j = 1; j <= m; j ++ ) cin>>B[j];
   work(A,s1,n);
   work(B,s2,m);
   long long res = 0;
   for(int i=1;i<=n;i++)
   {
       if(k%i!=0) continue;
       int j = k/i;
       if(j > m) continue;
       res+=(long long)s1[i]*s2[j];
   }
   cout<<res<<endl;
   return 0;
}

10. 整数分组
    dp问题状态计算中要能够不重不漏的枚举完所有能够到达当前状态的前一个状态，将状态看成图的话就是一个拓扑序。

/*
最优解一定可以有的性质
16. 每个区间内连续
17. 区间之间没有交集
18. 最后一段区间尽可能长
先排序，用k来记录比w[i]小5的最靠左的那个区间
*/
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 5010;
int w[N],f[N][N];
int n,m;
int main()
{
    cin>>n>>m;
    for (int i = 1; i <= n; i ++ ) cin>>w[i];
    sort(w+1,w+n+1);
    for (int i = 1,k=1; i <= n; i ++ )
    {
        while(w[i] - w[k] > 5) k++;
        for (int j = 1; j <= m; j ++ )
        {
            f[i][j] = max(f[i-1][j],f[k-1][j-1]+i-k+1);
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}