寒假CS每日打卡 Feb.13th

---

算法部分

1.Acwing 入门组每日一题
题目：质因数分解

已知正整数n是两个不同的质数的乘积，试求出较大的那个质数。

输入格式
输入只有一行，包含一个正整数n。

输出格式
输出只有一行，包含一个正整数p，即较大的那个质数。

数据范围
6≤n≤2∗10⁹
输入样例：
21
输出样例：
7

题解：
  简单枚举即可。

代码：

#include <iostream>

using namespace std;

int main(){
    int n, ans = 1;
    
    cin >> n;
    for(int i = 2; i * i <= n; i ++)
        if(n % i == 0)
            ans = n / i;
    cout << ans << endl;
    return 0;
}

2.Acwing 提高组每日一题
题目：合并果子

在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。
达达决定把所有的果子合成一堆。
每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。
可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。
达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。
因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。
假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使达达耗费的体力最少，并输出这个最小的体力耗费值。
例如有3种果子，数目依次为1，2，9。
可以先将1、2堆合并，新堆数目为3，耗费体力为3。
接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。
所以达达总共耗费体力=3+12=15。
可以证明15为最小的体力耗费值。

输入格式
输入包括两行，第一行是一个整数n，表示果子的种类数。
第二行包含n个整数，用空格分隔，第i个整数ai是第i种果子的数目。

输出格式
输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。
输入数据保证这个值小于231。

数据范围
1≤n≤10000,
1≤ai≤20000

输入样例：
3
1 2 9
输出样例：
15

题解：
  可以看出来是哈夫曼树（Huffman Tree）的裸题，使用小根堆来解决，c++ stl中的priority_queue拿来直接用，但是默认priority_queue是大根堆，我们将权值改为负值就成为小根堆了。

代码：

#include <iostream>
#include <queue>

using namespace std;

int main(){
    int n, a, ans = 0;
    priority_queue<int> Q;
    
    cin >> n;
    while(n --){
        cin >> a;
        //读取数据，将数据取反后加入堆中
        Q.push(-a);
    }
    
    while(true){
    	//取得最小的两个堆，合并，然后加入到堆中
        int a = Q.top();
        Q.pop();
        //只剩下一个元素，则无需再合并了，退出
        if(Q.empty())
            break;
        int b = Q.top();
        Q.pop();
        ans += -(a + b);
        Q.push(a + b);
    }
    cout << ans << endl;
    return 0;
}

3.LeetCode 每日一题
题目：找到所有数组中消失的数字

题解：
  个人觉得题目出得不大好，可能年初一小编玩疯了，hhh，来看一道单调栈，下一题 -->

其实没走多少，hhhh

4.滑动窗口的最大值
题目：

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值。

示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7

示例 2：
输入：nums = [1], k = 1
输出：[1]

示例 3：
输入：nums = [1,-1], k = 1
输出：[1,-1]

示例 4：
输入：nums = [9,11], k = 2
输出：[11]

示例 5：
输入：nums = [4,-2], k = 2
输出：[4]

提示：
1 <= nums.length <= 105
-104 <= nums[i] <= 104
1 <= k <= nums.length

题解：
  单调队列/栈的题目理解之后不是很难，单调队列原理戳这里，本题扫描一遍数组，利用单调队列维护区间内的最大值。

代码：

//first为元素的值，second为元素的位置索引
typedef pair<int, int> PII;
class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        deque<PII> Q;

        for(int i = 0; i < nums.size(); i ++){
        	//将小于其的元素pop
            while(!Q.empty() && Q.back().first < nums[i])
                Q.pop_back();
            //当前元素入队
            Q.push_back(PII(nums[i], i));
			//pop那些超出范围的元素
            while(!Q.empty() && Q.front().second + k <= i)
                Q.pop_front();
            //加入答案
            if(i >= k - 1)
                ans.push_back(Q.front().first);
        }
        return ans;
    }
};

5.通信线路
题目：

在郊区有 N 座通信基站，P 条 双向 电缆，第 i 条电缆连接基站Ai和Bi。
特别地，1 号基站是通信公司的总站，N 号基站位于一座农场中。
现在，农场主希望对通信线路进行升级，其中升级第 i 条电缆需要花费Li。
电话公司正在举行优惠活动。
农产主可以指定一条从 1 号基站到 N 号基站的路径，并指定路径上不超过 K 条电缆，由电话公司免费提供升级服务。
农场主只需要支付在该路径上剩余的电缆中，升级价格最贵的那条电缆的花费即可。
求至少用多少钱可以完成升级。

输入格式
第1行：三个整数N，P，K。
第2…P+1行：第 i+1 行包含三个整数Ai,Bi,Li。

输出格式
包含一个整数表示最少花费。
若1号基站与N号基站之间不存在路径，则输出”-1”。

数据范围
0≤K<N≤1000,
1≤P≤10000,
1≤Li≤1000000

输入样例：
5 7 1
1 2 5
3 1 4
2 4 8
3 2 3
5 2 9
3 4 7
4 5 6
输出样例：
4

题解：
  二分 + 最短路。假设需要花费为 W，那么设那些大于 W 的道路的权值为1，那些小于等于W的权值为0，接着使用最短路算法，如果最后1到 n 的距离大于K，说明需要K条大于W的路才能到 n ，即该方案不可行，因为超过了最大允许的免费道路，所以需要扩大花费W，否则缩小花费W，这样子二分找到答案。

代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int MAXN = 20010;
int head[MAXN], nxt[MAXN], ver[MAXN], edge[MAXN], dist[MAXN];
bool vis[MAXN];
int n, m, k, cnt = 0;
typedef pair<int, int> PII;

//使用数组来写邻接表
void add(int a, int b, int c){
    ver[++ cnt] = b;
    edge[cnt] = c;
    nxt[cnt] = head[a];
    head[a] = cnt;
}
//使用双向bfs检查方案是否合法
bool check(int mid){
	//初始化
    memset(dist, 0x3f, sizeof(dist));
    memset(vis, false, sizeof(vis));
    
    deque<int> Q;
    dist[1] = 0;
    Q.push_back(1);
    while(!Q.empty()){
        int cur = Q.front();
        Q.pop_front();
        if(vis[cur])
            continue;
        vis[cur] = true;
        for(int i = head[cur]; i; i = nxt[i]){
            if(edge[i] <= mid){
                if(dist[ver[i]] > dist[cur]){
                    dist[ver[i]] = dist[cur];
                    //加到队头，这样子能保证队头到队尾的距离始是递增的
                    Q.push_front(ver[i]);
                }
            }else{
                if(dist[ver[i]] > dist[cur] + 1){
                    dist[ver[i]] = dist[cur] + 1;
                    //加到队尾
                    Q.push_back(ver[i]);
                }
            }
        }
    }
    return dist[n] <= k;
}

int main(){
    int a, b, c;
    
    cin >> n >> m >> k;
    
    while(m --){
        cin >> a >> b >> c;
        //无向边 == 两条有向边
        add(a, b, c);
        add(b, a, c);
    }
    
    
    
    int le = 0, ri = 1000001, mid;
    //二分搜答案
    while(le < ri){
        mid = le + ri >> 1;
        if(check(mid))
            ri = mid;
        else
            le = mid + 1;
    }
    if(ri == 1000001)
        cout << -1 << endl;
    else
        cout << ri << endl;
    return 0;
}

---

书籍部分

算法竞赛.进阶指南 0x61最短路 单源点 ✔

---

PS.

1. 年初一 一过，在程序员眼里就是要上班啦，奋斗 ><
2. 刷题还得和算法书籍一起结合着看