在家复健前两天

Multiple of 2019（前缀和+同余）

同余的知识以后再补（大概）

解题思路：
根据同余的思想，每次寻找字符串片段**s[i,s.size()-1]**对2019取余的值，若该值在之前出现过，则说明此片段是2019的倍数
所以我们可以每次求字符串的后缀和，用一个数组cnt存储它出现的次数，加入到次数ans中，代码如下

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+10,M=2019;
string s;
ll h[N],cnt[N];
ll ans=0;
int main(){
    cin>>s;
    cnt[0]=1;//因为0是2019的倍数，所以第一次出现就需要ans++
    ll a=1;
    for(int i=s.size()-1;i>=0;i--){
        h[i]=(h[i+1]+a*(s[i]-'0'))%M;
        a=a*10%M;
        ans+=cnt[h[i]];
        cnt[h[i]]++;
    }
    cout<<ans;
    return 0;
}

Mountain Climbing S（贪心）

还是思考不到位啊

题解：
首先，贪心的想法和之前的做法是相同的，就是让更多的牛早到山顶；
我们把牛分成两类：1. up < down 2. up > down，up=down的归为任意一类是不影响的；
之后，考虑到up小的先到山顶不会拖慢后面的牛，我们把第一类都排在第二类前面，而且按up升序排；
第二类牛我们按down降序排，这个没上面那个显然，但是原因也很简单，下的慢的先下可以拖住后面的牛下山，减少出现山顶的牛已经下完了，下面的牛还没上完这种浪费的情况；
之后是计算时间，其实最初那个方法的贪心策略和上面应该是相同的，但是计算出了问题；
那组数据之所以被Hack，就是因为最初的方法认为第一个牛上山后，所有上下山是一起进行的，其实有可能出现不重叠的情况，于是少算了；
正确的做法是按之前那个策略排序后，O(n)模拟一下。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define x first
#define y second
const int INF=1e18,N=25100;
typedef pair<int,int>PII;
PII p[N];
int up[N],down[N];
bool cmp(PII a,PII b){
    if(a.x<a.y){
        if(b.x<b.y) return a.x<b.x;
        return true;
    }
    else{
        if(b.x<b.y) return false;
        return a.y>b.y;
    }
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        int a,b;
        cin>>a>>b;
        p[i]={a,b};
    }
    sort(p+1,p+n+1,cmp);
    for(int i=1;i<=n;i++) up[i]=up[i-1]+p[i].x;
    for(int i=1;i<=n;i++) down[i]=max(down[i-1],up[i])+p[i].y;
    cout<<down[n];
    return 0;
}

Grazing Patterns（DFS）

还是不会搜索啊呜呜呜

关于DFS函数的分析：
我们可以设置三个参数DFS(x,y,cnt)
x，y代表当前的横坐标纵坐标，cnt表示已经走过的草地块数
当cnt等于25-k并且从（1，1）走到（5，5）则说明本次搜索路径正确，ans++

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
bool vis[10][10],a[10][10];
int res=0,num=0,k,n;
int dx[5]={-1,1,0,0},dy[5]={0,0,1,-1};
void dfs(int i,int j,int num){
    if(num==n&&i==5&&j==5){
        res++;
        return ;
    }
    for(int z=0;z<4;z++){
        int x=i+dx[z],y=j+dy[z];
        if(x>=1&&x<=5&&y>=1&&y<=5&&!vis[x][y]&&!a[x][y]){
            vis[x][y]=true;
            dfs(x,y,num+1);
            vis[x][y]=false;
        }
    }

}
int main(){
    cin>>k;
    n=25-k;
    while(k--){
        int i,j;
        cin>>i>>j;
        a[i][j]=true;
    }
    vis[1][1]=true;
    dfs(1,1,1);
   // vis[1][1]=false;
    cout<<res;
}

奶酪（仍然是不会的DFS）

思路分析：
首先对每个奶酪洞按照z排序，遍历每个能从下表面到达的动依次进行搜索
dfs（u）u代表当前奶酪洞的序号，对当前洞u可以到达且之前没有去过的洞（剪枝）进行搜索

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
struct p{
    double x,y,z;
}ps[N];
bool vis[N];
bool cmp(p X,p Y){
    return X.z<Y.z;
}
int t,n,h,r,res,f;
bool check(p X,p Y){
    double dist=sqrt((X.x-Y.x)*(X.x-Y.x)+(X.y-Y.y)*(X.y-Y.y)+(X.z-Y.z)*(X.z-Y.z));
    if(dist<=2*r) return true;
    return false;
}
void dfs(int u){
    vis[u]=true;
    if(ps[u].z+r>=h){
        f=1;
        return ;
    }
    if(f) return ;
    for(int i=0;i<n;i++){
        if(!vis[i]&&check(ps[u],ps[i])) dfs(i);
    }
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>t;
    while(t--){
        memset(vis,false,sizeof vis);
        cin>>n>>h>>r;
        for(int i=0;i<n;i++){
            int x,y,z;
            cin>>x>>y>>z;
            ps[i]={x,y,z};
        }
        sort(ps,ps+n,cmp);
        f=0;
        for(int i=0;i<n;i++){
            if(ps[i].z<=r) dfs(i);
            if(f) break;
        }
        if(f) cout<<"Yes"<<'\n';
        else cout<<"No"<<'\n';
    }
    return 0;
}

Times 17（高精度）

思路：
17的二进制表示为10001，n乘一个17相当于n的二进制左移4为并加上一个n的二进制

#include<bits/stdc++.h>
using namespace std;
string s,s2;
vector<int> add(vector<int> &a,vector<int> &b){//使用引用速度更快
    vector<int> c;
    int t=0;
    for(int i=0;i<a.size()||i<b.size();i++){
        if(i<a.size()) t+=a[i];
        if(i<b.size()) t+=b[i];
        c.push_back(t%2);
        t/=2;
    }
   // cout<<t<<' ';
    while(t>=1) c.push_back(t%2),t/=2;
    return c;
}
int main(){
    cin>>s;
    s2=s;
    s+="0000";
    vector<int>va,vb,vc;
    for(int i=s.size()-1;i>=0;i--) va.push_back(s[i]-'0');
    for(int i=s2.size()-1;i>=0;i--) vb.push_back(s2[i]-'0');
    vc=add(va,vb);
    for(int i=vc.size()-1;i>=0;i--) cout<<vc[i];
    return 0;
}