笔试强训day23

打怪

你是一个勇士，现在你准备去森林刷毛球怪，你有两个属性（血量，攻击力），毛球怪也有这两个属性。当你遭遇一只毛球怪时你们会进入战斗，然后你和毛球怪轮流攻击（你先手），每次使对方的血量减去自己攻击力的数值，当一方的血量小于等于 0 时死亡。现在你想知道在自己活着的前提下最多杀死几只毛球怪。

输入描述:

第一行一个正整数t，代表测试数据组数。第二行四个正整数h，a，H，A，代表你的血量和攻击力以及毛球怪的血量和攻击力。所有整数大小不超过1000。

输出描述:

 共 t 行，每行一个整数x，代表最多能杀死多少毛球怪。如果能杀死无数只，输出-1。

#include <iostream>

using namespace std;

int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		int h, a, H, A;
		cin >> h >> a >> H >> A;
		if (a >= H)cout << -1 << endl;
		else {
			int m = (H - 1) / a + 1; //怪物能抗多少次
			int n = m - 1;  //玩家要受到多少次攻击
			int x = n * A;  //杀一直怪物会掉多少血
			int ret = (h-1) / x;
			cout << ret << endl;
		}

	}
	return 0;
}

---

字符串分类

牛牛有N个字符串，他想将这些字符串分类，他认为两个字符串A和B属于同一类需要满足以下条件：
A中交换任意位置的两个字符，最终可以得到B，交换的次数不限。比如：abc与bca就是同一类字符串。
现在牛牛想知道这N个字符串可以分成几类。

输入描述:

首先输入一个正整数N（1 <= N <= 50），接下来输入N个字符串，每个字符串长度不超过50。

输出描述:

输出一个整数表示分类的个数。

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>

using namespace std;

unordered_map<string, int>Hash;

int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		string s;
		cin >> s;
		sort(s.begin(), s.end());
		Hash[s]++;
	}
	cout << Hash.size() << endl;
	return 0;
}

---

城市群数量

给定一个 n 个节点的邻接矩阵 m。 节点定义为城市，如果 a 城市与 b 城市相连， b 与 c 城市相连，尽管 a 与 c 并不直接相连，但可以认为 a 与 c 相连，定义 a,b,c 是一个城市群。

矩阵 m[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，否则表示不相连。

请你找出共有多少个城市群。

数据范围： 1≤�≤200 1≤n≤200 ， 矩阵中只包含0 0 和1 1

直接贴了并查集的模板

class UnionFindSet { //不存在映射关系的并查集
  public:
    UnionFindSet(size_t n):
        _ufs(n, -1)
    { }
    void Union(int x, int y) {
        int root1 = FindRoot(x), root2 = FindRoot(y);
        if (root1 == root2)
            return;
        _ufs[root1] += _ufs[root2];
        _ufs[root2] = root1;
    }
    int FindRoot(int x) {
        if (_ufs[x] < 0)
            return x;
        return _ufs[x] = FindRoot(_ufs[x]);
    }
    bool InSet(int x, int y) {
        return FindRoot(x) == FindRoot(y);
    }
    size_t GetSize() {
        size_t ans = 0;
        for (int& x : _ufs)
            if (x < 0)
                ++ans;
        return ans;
    }
  private:
    vector<int>_ufs;
};

class Solution {
  public:
    int citys(vector<vector<int> >& m) {
        // write code here
        int n = m.size();
        UnionFindSet ufs(n);
        
        for(int i = 0;i<n;++i)
        {
            for(int j = 0;j<n;++j)
            {
                if(m[i][j])
                {
                    ufs.Union(i,j);
                }
            }
        }
        return ufs.GetSize();
    }
};

dfs

class Solution
{
public:
    bool vis[210] = { 0 }; // ⽤来标记当前位置是否已经搜索过
    int citys(vector<vector<int> >& m)
    {
        int n = m.size();
        int ret = 0;
        for (int i = 0; i < n; i++)
        {
            if (!vis[i])
            {
                ret++;
                dfs(m, i);
            }
        }
        return ret;
    }
    void dfs(vector<vector<int> >& m, int pos)
    {
        vis[pos] = true;
        for (int i = 0; i < m.size(); i++)
        {
            if (!vis[i] && m[pos][i])
            {
                dfs(m, i);
            }
        }
    }
};