4.9日刷题

1、P5198 [USACO19JAN]Icy Perimeter S
题意概括：给定一个地图，然后求连通块的周长和面积。
解题思路：面积就用dfs就能算出，周长求解的方式为在搜索的过程中，对于每一个点，如果周围越界了或者为点，周长++。

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

using namespace std;
typedef pair<int, int> PII;

const int N = 1010;
char g[N][N];
int st[N][N];
int n;
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

void dfs(int x,int y,int &area,int &c)
{
    st[x][y] = true;
    area++;
    for (int i = 0; i < 4; i ++ )
    {
        int tx = x+dx[i],ty = y+dy[i];
        if(tx < 1 || tx > n || ty < 1|| ty > n || g[tx][ty]=='.') c++;
    }
    for(int i=0;i<4;i++)
    {
        int nx = x+dx[i],ny = y+dy[i];
        if(nx < 1 || nx > n || ny < 1|| ny > n) continue;
        if(st[nx][ny] || g[nx][ny] == '.') continue;
        dfs(nx,ny,area,c);
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            cin>>g[i][j];
        }
    }
    int maxarea = 0,minc=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(!st[i][j] && g[i][j] == '#')
            {
                int area = 0,c = 0;
                dfs(i,j,area,c);
                if(area > maxarea || (area == maxarea && c < minc))
                {
                    maxarea = area,minc = c;
                }
            }
        }
    }
    cout<<maxarea<<" "<<minc<<endl;
    return 0;
}

2、机器人搬重物
题意概括：普通的路径问题+机器人有体积
解题思路：用给出的点作为机器人左上角的点，中点坐标需要左上角到达。用一个三维数组进行判重，注意如何求解这个点下一个状态有哪些。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include<unordered_map>
using namespace std;
typedef pair<int, int> PII;
const int N = 55;
int g[N][N],dist[N][N][5];
bool st[N][N][5]; //坐标和朝向用于判重
unordered_map<char,int> mp; //朝向对应的数字
int n,m;
int sx,sy,ex,ey;
char c;
struct Node
{
    int x,y,flag;
    Node(){};
    Node(int a,int b,int c) { x = a,y = b,flag = c;}
};
queue<Node> q;
Node path[N][N][5];
bool check(int x,int y)
{
    if(g[x][y] || g[x][y+1] || g[x+1][y] || g[x+1][y+1]) return true;
    return false;
}
vector<Node> get_state(int w,int x,int y)
{
    vector<Node> tmp;
    if(w == 1)
    {
        int flag1 = 0,flag2 = 0;
        tmp.push_back(Node(x,y,2)); //右转
        tmp.push_back(Node(x,y,4)); //左转
        if(x-1 > 0 && !check(x-1,y)) tmp.push_back(Node(x-1,y,w)),flag1 = 1; //前进一步
        if(flag1 &&!check(x-2,y)) tmp.push_back(Node(x-2,y,w)),flag2 = 1;
        if(flag2 &&!check(x-3,y)) tmp.push_back(Node(x-3,y,w));
    }
    else if(w == 2)
    {
        int flag1 = 0,flag2 = 0;
        tmp.push_back(Node(x,y,3)); //右转
        tmp.push_back(Node(x,y,1)); //左转
        if(y+1 < m && !check(x,y+1))tmp.push_back(Node(x,y+1,w)),flag1 = 1; //前进一步
        if(flag1  && !check(x,y+2))tmp.push_back(Node(x,y+2,w)),flag2 = 1;
        if(flag2  && !check(x,y+3))tmp.push_back(Node(x,y+3,w));
    }
    else if(w == 3)
    {
        int flag1 = 0,flag2 = 0;
        tmp.push_back(Node(x,y,4)); //右转
        tmp.push_back(Node(x,y,2)); //左转
        if(x+1 < n && !check(x+1,y)) tmp.push_back(Node(x+1,y,w)),flag1 = 1; //前进一步
        if(flag1 && x+2 < n && !check(x+2,y))tmp.push_back(Node(x+2,y,w)),flag2 = 1;
        if(flag2 && x+3 < n && !check(x+3,y))tmp.push_back(Node(x+3,y,w));
    }
    else if(w == 4)
    {
        int flag1 = 0,flag2 = 0;
        tmp.push_back(Node(x,y,1)); //右转
        tmp.push_back(Node(x,y,3)); //左转
        if(y-1 > 0 && !check(x,y-1)) tmp.push_back(Node(x,y-1,w)),flag1 = 1; //前进一步
        if(flag1 && y-2 > 0 && !check(x,y-2)) tmp.push_back(Node(x,y-2,w)),flag2 = 1;
        if(flag2 && y-3 > 0 && !check(x,y-3)) tmp.push_back(Node(x,y-3,w));
    }
    return tmp;
}
int bfs()
{
    st[sx][sy][mp[c]] = true;
    q.push(Node(sx,sy,mp[c]));
    dist[sx][sy][mp[c]] = 0;
    while(!q.empty())
    {
        auto t = q.front();
        q.pop();
        int tx = t.x,ty = t.y,w = t.flag;
        vector<Node> tmp = get_state(w,tx,ty);
        if(tx == ex && ty == ey) return dist[tx][ty][w];
        //cout<<"cur: "<<" "<<dist[tx][ty][w]<<" "<<tx<<" "<<ty<<" "<<w<<endl;
        //cout<<tmp.size()<<endl;
        for(auto c : tmp)
        {
            int nx = c.x,ny = c.y,nw = c.flag;
            if(st[nx][ny][nw] || check(nx,ny)) continue;
            //cout<<"x: "<<nx<<" "<<"y: "<<ny<<" "<<nw<<endl;
            path[nx][ny][nw] = t;
            dist[nx][ny][nw] = dist[tx][ty][w]+1;
            if(nx == ex && ny == ey) return dist[nx][ny][nw];
            st[nx][ny][nw] = true;
            q.push(c);
        }
        //cout<<endl;
    }
    return -1;
}
int main()
{
    mp['N'] = 1,mp['E'] = 2,mp['S'] = 3,mp['W'] = 4;
    cin>>n>>m;
    memset(g,1,sizeof g);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            cin>>g[i][j];
        }
    }
    cin>>sx>>sy>>ex>>ey;
    cin>>c;
    if(g[ex][ey] == 1) cout<<-1<<endl;
    else
    {
        int ans = bfs();
        cout<<ans<<endl;
    }
    return 0;
}

3、砝码称重
题意概括：给定一个数组，求去掉m个数之后剩余的数能组成的和的情况的最大值。
解题思路：dfs+背包。用dfs枚举去掉m个数的所有情况，然后dp求解能组成的数，f[i][j]表示取第i个数时，能组成的和j的情况。f[j] = f[j-w[i]] && f[j] ,f[0] = 1，逆序枚举

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
int n,m,ans;
const int N = 25,M = 2010;
int w[N];
bool st[25],f[M];
int dp(vector<int>& tmp)
{
    int sum = 0;
    memset(f,0,sizeof f);
    int len = tmp.size();
    f[0] = 1;
    for(int i=0;i<len;i++)
    {
        for(int j=M;j>=0;j--)
        {
            if(j + tmp[i] <= M && f[j]) f[j+tmp[i]] = 1;
        }
    }
    for(int i=1;i<=M;i++)
    {
        if(f[i]) sum++;
    }
    return sum;
}
void dfs(int index,int start)
{
    if(index == m)
    {
        vector<int> tmp;
        for(int i=0;i<n;i++)
        {
            if(!st[i]) tmp.push_back(w[i]);
        }
        ans = max(ans,dp(tmp));
        return;
    }
    for(int i=start;i<n;i++)
    {
        if(!st[i])
        {
            st[i] = true;
            dfs(index+1,i+1);
            st[i] = false;
        }
    }
}
int main()
{
    cin>>n>>m;
    for (int i = 0; i < n; i ++ ) cin>>w[i];
    dfs(0,0);
    cout<<ans<<endl;
    return 0;
}

4、CF510B Fox And Two Dots
题意概括：求给定二维矩阵中是否存在环
解题思路：dfs每一个没有遍历过的点，判断存在环的条件为下一个浏览的位置是我之前浏览过的点，父节点除外。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 55;
int n,m,ex,ey;
char g[N][N];
int sum = 0,flag = 0; // 当前节点个数,是否找到答案
bool st[N][N];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

// px,py表示是x,y的父节点，第一个节点的父节点是本身
bool dfs(int x,int y,int px,int py)
{
    if(st[x][y]) return true;
    st[x][y] = true;
    for (int i = 0; i < 4; i ++ )
    {
        int nx = x+dx[i],ny = y+dy[i];
        if(nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
        if((nx == px && ny == py) || g[nx][ny] != g[x][y]) continue;
        if(dfs(nx,ny,x,y)) return true;
    }
    return false;
}
int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++) cin>>g[i];
    for (int i = 0; i < n; i ++ )
    {
        for(int j = 0;j < m; j ++)
        {
            if(!st[i][j] && dfs(i,j,i,j))
            {
                cout<<"Yes"<<endl;
                return 0;
            }
        }
    }
    cout<<"No"<<endl;
    return 0;
}

5、正方形计数
题意概括：给定N个点，求解以其中四个点为顶点的正方形数量
解题思路：枚举正方形对角线的两个点，根据公式可以求出另外两个点，判断这两个点是否存在即可。另外两个点公式：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
typedef pair<double, double> PDD;
const int N = 110,M = 510;
map<PDD,int> mp;
int n;
PDD alls[M]; 
int main()
{
    cin>>n;
    for (int i = 0; i < n; i ++ )
    {
        int x,y;
        cin>>x>>y;
        mp[{x,y}] = 1;
        alls[i] = {x,y};
    }
    int ans = 0;
    for (int i = 0; i < n; i ++ )
    {
        for (int j = i+1; j < n; j ++ )
        {
            double x1 = alls[i].first,y1 = alls[i].second;
            double x2 = alls[j].first,y2 = alls[j].second;
            double x3 = (x1+x2)/2 + (y1-y2)/2,y3 = (y1+y2)/2+(x2-x1)/2;
            double x4 = (x1+x2)/2 + (y2-y1)/2,y4 = (y1+y2)/2+(x1-x2)/2;
            if(mp[{x3,y3}] && mp[{x4,y4}]) ans++;
            
        }
    }
    cout<<ans/2<<endl;
    return 0;
}

6、卡牌
题意概括：这个题题意很明显
解题思路：贪心求解。题解

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
typedef pair<int, int> PII;
const int N = 2e5+10;
int a[N],b[N];
int n,k;
vector<PII> tmp;
int main()
{
    cin>>n>>k;
    for (int i = 0; i < n; i ++ ) cin>>a[i];
    for (int i = 0; i < n; i ++ ) cin>>b[i];

    int sum = 0; // 记录和
    vector<int> v; // 记录取背面朝上的情况的序号
    for (int i = 0; i < n; i ++ )
    {
        if(b[i] < a[i])
        {
            sum+=b[i];
            v.push_back(i);
        }
        else
        {
            sum+=a[i];
        }
    }
    if(n-v.size()>=k) cout<<sum<<endl;
    else
    {
        // 从背面朝上的卡牌中选取(k-n+v.size())张牌朝上
        // 求出a[v[i]]和b[v[i]]的间隔
        for(auto x : v)
        {
            tmp.push_back({a[x]-b[x],x});
        }
        sort(tmp.begin(),tmp.end());
        int rest = k-n+v.size();
        for(int i=0;i<tmp.size();i++)
        {
            sum+=tmp[i].first;
            rest--;
            if(rest == 0) break;
        }
        cout<<sum<<endl;
    }
    return 0;
}

7、查询字符串
题意概括：无
解题思路：题解

#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_map>
using namespace std;
const int N = 1e4+10;
int n,q;
unordered_map<string,int> cnt;
unordered_map<string,string> apper; 
void deal(string str)
{
    int length = str.size();
    unordered_map<string,int> um; // 一个字符串只出现一次子串
    for(int len = 1;len<=length;len++)
    {
        int i = 0;
        while(i+len-1 < length)
        {
            string tmp = str.substr(i,len);
            if(um[tmp] == 0)
            {
                cnt[tmp]++;
                um[tmp] = 1;
                apper[tmp] = str;
            }
            i++;
        }
    }
}
int main()
{
    cin>>n;
    string str;
    for (int i = 0; i < n; i ++ )
    {
        cin>>str;
        deal(str); //处理每个字符串可能产生的子串
    }
    cin>>q;
    while(q--)
    {
        cin>>str;
        cout<<cnt[str]<<" ";
        if(cnt[str]==0) cout<<"-"<<"\n";
        else cout<<apper[str]<<"\n";
    }
    return 0;
}