C++测试题笔记

C++练习题

1：
现在有n个物品，每一个物品都有一个价值，现在想将这些物品分给两个人，要求这两个人每一个人分到的物品的价值总和相同（个数可以不同，总价值相同即可），剩下的物品就需要扔掉，现在想知道最少需要扔多少价值的物品才能满足要求分给两个人。

要求：时间复杂度O(3^n)，空间复杂度O(n)O(n)
输入描述

第一行输入一个整数 T，代表有 T 组测试数据。
对于每一组测试数据，一行输入一个整数 n ，代表物品的个数。

接下来 n 个数，a[i] 代表每一个物品的价值。

1<= T <= 10
1 <= n <= 15
1 <= a[i] <= 100000

输出描述

对于每一组测试数据，输出一个答案代表最少需要扔的价值。

示例1
输入

1
5
30 60 5 15 30

输出

20

实际上解题思路就是穷举法，暴力解法。一个一个尝试，最终res最小就是答案

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//定义两组数据的累加和  从0开始dfs每种可能，遇到两者相同的情况，就记录此时需要扔掉
//选择问题  两个人从0开始拿物品，遇到一个物品有三种选择，给第一个人，给第二个人，扔掉。
//走到结尾就找到舍弃价值最小的那一个节点

int res = INT_MAX;//最小扔掉的价值 //INT_MAX表示一个很大的📄
void dfs(vector<int>& nums,int result1,int result2,int sum,int index,int n)
{
    //一直选择到最后一个数字才返回
    if (index == n)
    {
        if (result1 == result2)
        {
            res = min(res, sum - result1 - result2);
        }
        return;
    }

    //选择环节  每次进入选择环节都有三种选择
    dfs(nums,result1 + nums[index], result2, sum, index + 1,n);
    dfs(nums,result1,result2 + nums[index], sum, index + 1,n);
    dfs(nums,result1,result2,sum,index+1,n);
}

int main()
{
    int t;
    cin >> t;
    while (t--)//一个while输出一个答案
    {
        int n;
        cin >> n;
        int temp;

        vector<int> nums;//输入数组 
        //使用容器
        
        for (int i = 0; i < n; i++)
        {
            cin >> temp;
            nums.push_back(temp);
        }

        int sum = 0;
        for (auto i : nums)
        {
            sum += i;
        }

        dfs(nums, 0, 0, sum, 0, n);
        cout << res << endl;
        res = INT_MAX;

    }
}

知识点
1.INT_MAX
表示一个很大的数 INT_MIN
头文件#include

2.vector<int> nums
使用容器，确保答案在一行输入

3.for (auto i : nums)
for (auto x : nums)的作用：
相当于：
for (vector< int >::iterator iter = nums.begin(); iter != nums.end(); iter++)
for(auto a:b)中b为一个容器，效果是利用a遍历并获得b容器中的每一个值，但是a无法影响到b容器中的元素。

现在有n个人排队买票，已知是早上8点开始卖票，这n个人买票有两种方式：

第一种是每一个人都可以单独去买自己的票，第 i 个人花费 a[i] 秒。

第二种是每一个人都可以选择和自己后面的人一起买票，第 i 个人和第 i+1 个人一共花费 b[i] 秒。

最后一个人只能和前面的人一起买票或单独买票。

由于卖票的地方想早些关门，所以他想知道他最早几点可以关门，请输出一个时间格式形如：08:00:40 am/pm

时间的数字要保持 2 位，若是上午结束，是 am ，下午结束是 pm

进阶：时间复杂度O(n) ,空间复杂度O(n)

输入描述

第一行输入一个整数 T，接下来有 T 组测试数据。

对于每一组测试数据：输入一个数 n，代表有 n 个人买票。

接下来n个数，代表每一个人单独买票的时间 a[i]。

接下来 n-1 个数，代表每一个人和他前面那个人一起买票需要的时间 b[i]
1<= T <=100
1<= n <=2000
1<=a[i] <=50
1<= b[i] <=50

输出描述

对于每组数据，输出一个时间，代表关门的时间 。

示例1
输入

2
2
20 25
40
1
8

输出

08:00:40 am
08:00:08 am

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<int> dp(n + 1, 0);     
        vector<int> single(n);
        for (int i = 0; i < n; ++i) {
            cin >> single[i];
        }
        dp[1] = single[0];
        for (int i = 2; i <= n; ++i) {
            int twoSum;
            cin >> twoSum;
            dp[i] = min(dp[i - 1] + single[i - 1], dp[i - 2] + twoSum);   //直接就记录了第i个人最短使用时间
        }

        int seconds = dp[n];
        int hh, mm, ss;
        ss = seconds % 60;
        mm = (seconds / 60) % 60;
        hh = seconds / 3600;
        hh += 8;
        char s[3] = "am";
        if (hh > 12) {
            hh -= 12;
            s[0] = 'p';
        }
        printf("%02d:%02d:%02d %s\n", hh, mm, ss, s);

    }


    return 0;
}

vector<int> dp(n + 1, 0);    

n+1个值全都都赋值为0

dp[i] = min(dp[i - 1] + single[i - 1], dp[i - 2] + twoSum);   

本题的思想是当第i个人时，时间最短，实际就是比较是否将最后两个人合起来买票？最后一个人单独买票+前面n-1人用时最短；还是，后两个人一起买票+前n-2个人用时最短
实际上是迭代递归思想

3.小易得到了一个仅包含大小写英文字符的字符串，该字符串可能不是回文串。（“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串，“asds”就不是回文串。）小易可以在字符串尾部加入任意数量的任意字符，使其字符串变成回文串。

现在请你编写一个程序，程序要能计算出小易可以得到的最短回文串。

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

using namespace std;

int main()
{
    string s;
    cin >> s;
    string t(s.rbegin(), s.rend());
    int n = s.size();
    vector<int> ne(n * 2 + 2);    //next[]
    s = ' ' + t + '*' + s;
    for (int i = 2, j = 0; i <= n * 2 + 1; i++)   //KMP
    {
        while (j && s[i] != s[j + 1]) j = ne[j];   //回溯
        if (s[i] == s[j + 1]) j++;
        ne[i] = j;         //next[]
    }
    int len = ne[n * 2 + 1];
    string s1 = s.substr(1, len);        //s1 is huiwen。    substr()截取string
    string s2 = s.substr(len + 1, n - len); // s2 isn't huiwen
    string res = string(s2.rbegin(), s2.rend()) + s1 + s2;

    cout << res << endl;

    return 0;
}

在一次聚会中，教授们被要求写下自己认可哪位教授的学术成果（也可以写自己，且可能出现重复）。已知，如果教授 A 认可教授 B ，且教授 B 认可教授 C，那么即可视为教授 A 也认可教授 C。现在我们想知道有多少对教授是两两互相认可的？

输入描述

第一行两个正整数，教授人数 n，以及认可关系总数 m ；
接下来 m 行，每行两个正整数 x 和 y，表示教授 x 认可教授 y（x ,y可能相等且可能出现重复）

输出描述:

一行一个数字表示答案，即互相认可的教授有多少对。

#include <iostream>
#include <vector>
using namespace std;
void Tarjan(vector<vector<int>>& G, vector<int>& low, vector<int>& dfn, vector<bool>& visited, vector<int>& st, int& time, int& res, int index){
    st.push_back(index);
    //标记入栈的节点
    visited[index] = true;
    dfn[index] = low[index] = time++;
    //对index所连通的点进行访问
    for(auto v : G[index])
    {
        //若index所联通的v点尚未被访问，则对其进行访问,访问后可能得到更低的low值，则可以更新index的low值
        if(!dfn[v])
        {
            Tarjan(G, low, dfn, visited, st, time, res, v);
            low[index] = min(low[index], low[v]);
        }
            //若此节点被访问过，且在栈中，则有可能可以更新index的low值
        else if(visited[v])    //the node need in the stack
        {
            low[index] = min(low[index], low[v]);
        }
        //若此节点被访问过但不在栈中，则无需操作，为单独的一个强连通分量，不可能与index形成强连通分量
    }
    //若遍历完index的所有连通的节点后，并不能更新low[index]的时间戳，则表示index自身就是一个强连通分量的顶点
    if(dfn[index] == low[index])
    {
        int cnt = 0;
        int tmp;
        do{
            tmp = st.back();
            st.pop_back();    //vector
            visited[tmp] = false;
            ++cnt;
        } while(tmp != index);
        res += cnt * (cnt - 1) / 2;
    }
}

int main(){
    int n, m;
    cin >> n >> m;
    vector<vector<int>> G(n + 1);    //二维数组
    for(int i = 0; i < m; ++i)
    {
        int src, dst;
        cin >> src >> dst;
        G[src].push_back(dst);
    }

    int time = 0;
    //low[i]存放i节点由有向图可回溯到的最早时间戳
    vector<int> low(n + 1);
    //dfn[i]表示i点被访问到的真实时间戳
    vector<int> dfn(n + 1);
    //标记该节点是否在栈中
    vector<bool> visited(n + 1, false);
    //vector模拟栈
    vector<int> st;    //stack
    //存储结果  result
    int res = 0;   
    for(int i = 1; i < n + 1; ++i)
    {
        //若此前未访问过此节点，则访问
        if(!dfn[i])
            Tarjan(G, low, dfn, visited, st, time, res, i);
    }
    cout << res << endl;
    return 0;
}
 

这个使用tarjan算法，通过求强连通分量计算，计算结果。
学习时注意tarjan算法的原理。
还有算法中栈用vector容器代替节约空间和时间，`st.pop_back();`  入栈  `st.pop_back();` 出栈
还有注意vector 数组的用法。 `vector<vector<int>> G(n + 1);`