Zut_round 9(搜索

A 题目传送门

思路：在Y，M 处用 bfs 分别跑一边图，记录两个人到每个'@'的最小时间。最后再遍历一遍数组得到两个相加的结果的最小值，即答案。

//这道题跟蓝桥杯的一道题差不多 贴个链接

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int qs=1e6+7;
const int inf=0x3f3f3f3f;
char C[207][207];
int vis[207][207];                // 判重 
int A[207][207];
int B[207][207];
int n,m; 
struct node
{
    int x,y;
    int num;
    node(){}                    // 用于在队列中存结构体 
    node(int x,int y,int num):x(x),y(y),num(num){};
}t,v;
queue<node> q;                    //队列 bfs 遍历
int l[4]={-1,1,0,0};            // 两个数组对应移动方向 
int r[4]={0,0,-1,1};
void bfs(int x,int y,int S[][207])
{
    int i,j;
    for(i=0;i<=n;++i)             // 重置数组 
    for(j=0;j<=m;++j)             // ！！！这里，，，一开始写成 j<=n ，半天愣是没找出来，浪费了50分钟时间
    vis[i][j]=0;                // 之前一直用 memset 的，后来听说 memset 有问题就没用过 
    t.x=x; t.y=y; t.num=0;
    vis[t.x][t.y]=1;            //标记 
    q.push(t); 
    while(!q.empty())
    {
        t=q.front(); q.pop();
        for(i=0;i<4;++i)        //移动 
        {
            v.x=t.x+l[i];
            v.y=t.y+r[i];
            v.num=t.num+11;
            if(v.x<1||v.x>n||v.y<1||v.y>m||C[v.x][v.y]=='#'||vis[v.x][v.y]==1) continue;
            S[v.x][v.y]=v.num;    
            vis[v.x][v.y]=1;
            q.push(v);
        }        
    }
    return;
}
int main()
{
    int i,j,k;
    while(cin>>n>>m)
    {
    for(i=1;i<=n;++i) cin>>C[i]+1;
    for(i=1;i<=n;++i)
    for(j=1;j<=m;++j)
    {
        if(C[i][j]=='M') bfs(i,j,A);
        if(C[i][j]=='Y') bfs(i,j,B);
    }
    int ans=inf;
    for(i=1;i<=n;++i)
    for(j=1;j<=m;++j)
    {
        if(C[i][j]=='@'&&A[i][j]&&B[i][j]) 
        ans=min(ans,A[i][j]+B[i][j]);
        A[i][j]=0;
        B[i][j]=0;
    }
    cout<<ans<<endl;    
    }
    
    return 0;
}

B 题目传送门

思路：将图看成两部分，从（1，1）和（n,m）处分别dfs跑一遍，将贴近对角线的一条线上的点设为两部分的搜索结束点（使两边搜索复杂度尽可能平均） 因为a_i,j<=1e18,可用STL库函数map记录,map[x][y][temp]记录在(x,y)处异或值为temp的路径个数。

//刚开始想dfs或bfs把整个图的每一条边都跑一边，后来被学长提醒后才明白。n,m<=20,直接从(1,1)遍历到(n,m)最大复杂度可达到 2⁴⁰.

附: a^b^a=b

#include<bits/stdc++.h> 
using namespace std;
typedef long long ll;
ll A[23][23];
map<ll,ll> mp[23][23];
int n,m; 
ll k;
bool check(int x,int y)            //判断是否越界 
{
    if(x<1||y<1||x>n||y>m) return false;
    return true;
}
ll ans=0;
void dfs(int x,int y,ll temp)        //从（1，1）遍历 
{
    if(!check(x,y)) return;
    if(x+y==n+1)                    //自己规定的结束点 
    {
        mp[x][y][temp]++;            //记录 
        return;
    }
    dfs(x+1,y,temp^A[x+1][y]);
    dfs(x,y+1,temp^A[x][y+1]);
}
void dfs1(int x,int y,ll temp)
{
    if(!check(x,y)) return;
    if(x+y==n+1)
    {
        ans+=mp[x][y][temp^k^A[x][y]];        //因为终点多被异或一次，要异或回来。 
        return;
    }
    dfs1(x-1,y,temp^A[x-1][y]);
    dfs1(x,y-1,temp^A[x][y-1]);
}
int main()
{
    int i,j;
    cin>>n>>m>>k;
    for(i=1;i<=n;++i) 
    for(j=1;j<=m;++j) cin>>A[i][j];
    dfs(1,1,A[1][1]);
    dfs1(n,m,A[n][m]);
    cout<<ans<<endl;
    return 0;
}

D 题目传送门

思路：设电梯在i楼,则对于在第j层的用户来说电梯耗费电力有 : (abs(i-j)+j+i)*2*A[j] ,剩下就嗯遍历，找出最优解即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int qs=1e6+7;
const int inf=0x3f3f3f3f;
int n,m; 
int A[qs];
int main()
{
    int i,j;
    cin>>n;
    int x=0;
    for(i=0;i<n;++i)     cin>>A[i];
    int ans=inf;
    for(i=0;i<n;++i)
    {
        int fx=0;
        for(j=1;j<n;++j)
        {
            fx+=(abs(i-j)+j+i)*2*A[j];
        }
        ans=min(ans,fx);
    }
    cout<<ans<<endl;
    return 0;
}

E 题目传送门

思路：若啤酒总量小于杯子数，返回 -1。否则啤酒总量减去杯子数量再除以桶数得到平均值，平均值与桶中最小的啤酒量作比较，取小的即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,m; 
int main()
{
    ll i,j,k;
    cin>>n>>m;
    ll sum=0,x;
    ll y=1e18;
    for(i=1;i<=n;++i)
    {
        cin>>x;
        y=min(x,y);
        sum+=x;
    }
    ll ans=0;
    if(sum<m) ans=-1;
    else{
        ans=(sum-m)/n;
        ans=min(ans,y);
    }
    cout<<ans<<endl;
    return 0;
}

F 题目传送门

题目大意：求只有'a'组成的子序列个数，若子序列长度大于1，则子序列中任意 两两 'a' 在原字符串中的位置间都有至少一个 ‘b' .

思路：设 temp 为任意相离最近两个'b'之间的 'a' 的个数+1（此处+1是因为有可能不选这个区间的 'a'）。这个区间里面的 ’a' 不能相互组合。则用 temp 乘以这个区间之前已经形成的子序列个数，就是为到目前区间为止总子序列个数（包括空串），递推到字符串结束。最后再减去每个区间都不选的情况（即空串）。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod= 1e9+7;
int n,m; 
int main()
{
    string s;
    cin>>s;
    s+='b';
    ll temp=1;
    ll ans=1;
    for(int i=0;i<s.size();++i)
    {
        if(s[i]=='b') 
        {
        ans=ans*temp%mod;
        temp=1;
        }
        if(s[i]=='a') temp++;
    }
    
    cout<<ans-1<<endl;
    return 0;
}

5.5 补 G: 题目传送门

树上dp,dfs一边即可。

#includ<bits/stdc++.h> 
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int qs=3e5+7;
int n,m;
ll dp[qs];
ll w[qs];
ll ans=0;
struct node
{
    ll x,y;
    node(){}
    node(ll x,ll y):x(x),y(y){};
}t;

vector<node> v[qs];
void dfs(ll temp,ll fa)
{
    ans=max(ans,dp[temp]);
    for(int i=0;i<v[temp].size();++i)
    {
        ll x=v[temp][i].x;    
        ll y=v[temp][i].y;    
        if(x==fa) continue;
        dfs(x,temp);
        ll dig=dp[x]-y;
        ans=max(ans,dp[temp]+dig);
        dp[temp]=max(dp[temp],w[temp]+dig);
    }
}
int main()
{
    ll u,vv,k,i,j;
    cin>>n;
    for(i=1;i<=n;++i) 
    {
    cin>>w[i];     dp[i]=w[i];
    }
    for(i=1;i<n;++i) 
    {
        cin>>u>>vv>>k;
        v[u].push_back(node(vv,k));
        v[vv].push_back(node(u,k));
    }
    dfs(1,0);
    cout<<ans<<endl;
    return 0;
}

おもしろい