自己在秋招过程中遇到的算法笔试题，包含中大厂，都附解析！
汽水瓶
如果汽水瓶数目为1或者0，那么一瓶都喝不到
如果汽水瓶数目为2或者3，那么只能喝到一瓶
如果为2，喝到一瓶后手里一个瓶子都没有了，没法继续循环下去
如果为3，喝到一瓶后手里只剩一个瓶子，没法继续循环下去
如果汽水瓶数目大于3，每次耗费三个瓶子喝到一瓶，然后多了一个瓶子，即每一轮耗费两个瓶子
# include <iostream>
using namespace std;
unsigned int sln(unsigned int N){
if (N == 2 || N == 3) {
return 1;
}
if (N <= 1){
return 0;
}
unsigned int Total = 0;
while (N > 3) {
N -= 2;
Total++;
if (N == 2)
{
Total++;
N = 0;
}
if (N == 3)
{
Total++;
N = 1;
}
}
return Total;
}
int main(){
unsigned int N;
while (cin >> N) {
if (N == 0) break;
cout << sln(N) << endl;
}
return 0;
}
明明的随机数
//方法一： 暴力版本
#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main() {
int n;
cin>>n;
int m;
vector<int>v;
while(n--){
cin>>m;
v.push_back(m);
}
sort(v.begin(),v.end());
cout<<v[0]<<endl;
for(int i=1;i<v.size();i++){
if(v[i]!=v[i-1]){
cout<<v[i]<<endl;
}
}
}
//方法二：STL（set）版本
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int m;
set<int>us;//插入有序
while(n--){
cin>>m;
us.insert(m);
}
for(auto &i:us){
cout<<i<<endl;
}
}
**进制转换
**
#include <iostream>
using namespace std;
int main() {
int a;
while (cin >> hex>> a) { // 注意 while 处理多个 case
cout << a << endl;
}
}
Words
#include<bits/stdc++.h>
using namespace std;
int main(){
string str="";
while(getline(cin,str)){
int n=str.size();
int countspace=0;
double ans=0;
for(int i=0;i<str.size();i++){
if(str[i]==' '){
countspace++;
}
}
ans=1.0*(n-countspace)/(1.0*(countspace+1));
cout<<fixed<<setprecision(2)<<ans<<endl;
}
return 0;
}
Vowel
#include<set>
#include<string>
#include<iostream>
using namespace std;
int main(){
string str="";
string ans="";
set<char>se;
se.insert('a');
se.insert('e');
se.insert('i');
se.insert('o');
se.insert('u');
se.insert('A');
se.insert('E');
se.insert('I');
se.insert('O');
se.insert('U');
while(getline(cin,str)){
for(int i=0;i<str.size();i++){
if(se.find(str[i])==se.end()){
ans.push_back(tolower(str[i]));
}
else{
ans.push_back(toupper(str[i]));
}
}
cout<<ans;
}
return 0;
}
计算字符串重新排列数
栈数据合并
整体代码
#include <iostream>
#include<stack>
#include <sstream>
using namespace std;
//没有消除时，栈里面大小一直是1
int main() {
stack<int> s;
string input;
//输入:10 20 50 80 1 1
//输出：2 160
getline(cin, input);
istringstream iss(input);//输入的一行挨个读取
int num;
while (iss >> num) {
if (s.empty()) {
s.push(num);
continue;//关键
}
int sum = num;
while (!s.empty() && s.top() <= num) {
int top = s.top();
s.pop();
sum += top;
if (sum == top * 2) {
sum = top * 2;
continue;//关键
}
if (!s.empty() && sum == top * 2 + s.top()) {
sum = top * 2 + s.top();
s.pop();
}
break;
}
s.push(sum);
}
while (!s.empty()) {
cout << s.top() << " ";
s.pop();
}
return 0;
}
寻找密码串
C++字符串转数字： stoi C语言字符串转数字：atoi(s.c_str())
C++数字转字符串to_string
整体代码
#include <iostream>
#include <string>
#include<set>
#include <algorithm>
using namespace std;
bool is_valid(string s) {
return set<char>(s.begin(), s.end()).size() == 1;
}
int main() {
string a, c;
long long b;
cin >> a >> b >> c;
long long size = a.length();
long long ans = 0;
for (int i = 0; i < size; i++) {
for (int len = 0; len < 13; len++) {
if (i + len >= size) {
break;
}
long long now = stoll(a.substr(i, len + 1));
if (c == "+") {
if (is_valid(to_string(now + b))) {
ans = max(ans, now);
}
}
else if (c == "-") {
if (is_valid(to_string(now - b))) {
ans = max(ans, now);
}
}
else {
if (is_valid(to_string(now * b))) {
ans = max(ans, now);
}
}
}
}
cout << ans << endl;
return 0;
}
染色服务器，最短耗费时间走完所有的服务器-5.10
#include <iostream>
#include <queue>
#include <vector>
#include <unordered_map>
#include <climits>
using namespace std;
int main() {
int n;
cin >> n;//几个服务器
int m;
cin >> m;//几条路径
unordered_map<int, int> sysTime;
unordered_map<int, vector<pair<int, int>>> nxs;
//m条路径从哪到哪，耗时多久
for (int i = 0; i < m; i++) {
int s, d, t;
cin >> s >> d >> t;
if (s != d)
nxs[s].push_back({ d, t });
else
sysTime[s] = t;
}
//从哪个服务器开始
int start;
cin >> start;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> h;
h.push({ 0, start });
vector<int> dis(n + 1, INT_MAX);
dis[start] = 0;
while (!h.empty()) {
int time = h.top().first;
int node = h.top().second;
h.pop();
for (auto& nx : nxs[node]) {
int nxNode = nx.first;
int nxTime = nx.second;
if (dis[nxNode] > time + sysTime[nxNode] + nxTime) {
h.push({ time + sysTime[nxNode] + nxTime, nxNode });
dis[nxNode] = min(dis[nxNode], time + sysTime[nxNode] + nxTime);
}
}
}
int cnt = 0, res = 0;
for (int d : dis) {
if (d != INT_MAX) {
cnt++;
res = max(res, d);
}
}
cout << cnt << " " << res << endl;
return 0;
}
小美的送花路线
根据题设，考虑树状结构。求：
sum1：从花店到所有客户地址的距离之和;
sum2：骑手实际走的最短路程，且最后一趟不需再返回。
求sum1：
根据输入的u、v、w，对于任意节点都能写出dp[v]=dp[u]+w，从而得到sum1。
对于例子1来说，sum1+=dp[v]。如dp[5]=dp[2]+1=3+1=4。sum1=3+1+2+4=10。
求sum2：
要求最短路径，根据最后一趟不需返回，可知最后一趟一定是从花店到最远的客户地址处，这部分距离只需计算一次，其余的到其他客户地址的距离需要计算往返路程。因此sum2+=2×w，还要-maxlen，其中maxlen是dp[v]中的最大值。
对于例子1来说，离花店最远的客户地址是5，路程中还途径了客户1。因此，sum2=2×(3+1+2+1)-(3+1)=10。
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n;
cin>>n;
vector<int>dp(n,0);
int sum1 = 0,maxlen = 0,sum2 = 0;
int u,v,w;
for(int i=0;i<n-1;i++){
cin>>u>>v>>w;
dp[v] = dp[u]+w;
sum2 += w*2;
maxlen = max(dp[v],maxlen);
sum1 += dp[v];
}
cout << sum1 << " " << sum2-maxlen;
}
小美的评分计算器
需注意的点：
①输入的是1星到5星的评价的数量；
②两个整数相除还是整数，需要用强制转换成小数；
③需要考虑输出为0.0的情况。
④不四舍五入的小数去尾的实现：乘整十（一位小数）向下取整再除十，使用fixed和setprecision控制实数部分及小数部分精度
fixed 和 setprecision 是用来控制输出浮点数精度和格式的两个重要工具。
fixed 是一个 C++ 标准库中的输出流修饰符，它用于指示输出的浮点数使用定点表示法而非默认的科学计数法。使用 fixed 后，输出的浮点数会以固定的小数位数格式进行输出。
fixed 是一个全局性质的修饰符，一旦使用，它会一直生效，直到被另外的修饰符覆盖为止。
setprecision 是另一个输出流修饰符，用于指定输出浮点数的小数位数。
向上取整：ceil，向下取整：floor，四舍五入：round
#include<bits/stdc++.h>
using namespace std;
int main(){
int n1,n2,n3,n4,n5;
cin>>n1>>n2>>n3>>n4>>n5;
double rate = 0;
rate = (double)(1*n1+2*n2+3*n3+4*n4+5*n5)/(n1+n2+n3+n4+n5);
if(n1==0&&n2==0&&n3==0&&n4==0&&n5==0){
cout<<"0.0";
}
else{
cout<<fixed<<setprecision(1)<<floor(rate*10.0)/10.0;
}
}
小美的外卖省钱计划
#include <iostream>
using namespace std;
int main() {
int n;
cin>>n;
int x=0, y=0;
int sum1=0,sum2=0;
for(int i=0;i<n;i++){
cin>>x>>y;
if(x>y){
sum2+=(x-y);
sum1+=x;
}
else{
sum1+=y;
}
}
cout<<sum1<<" "<<sum2;
}
小美的代金券要过期啦
例子中是从后向前进行消消乐的，因此考虑使用栈结构，将序列元素入栈后，当栈顶元素和序列中元素相等时，将输入的x＋1。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
int x = 0;
cin>>n;
int* s = new int[n];
for(int i=0;i<n;i++)
{
cin>>s[i];
}
stack<int> nums;
nums.push(s[0]);
for(int i=1;i<n;i++){
while(!nums.empty()&&s[i]==nums.top()){
nums.pop();
s[i]++;
x++;
}
nums.push(s[i]);
}
cout<<x;
}
字符分割
如给你一串字符“path=/chat.openai.com, language=c++, path=baidu.com",
输入 2 path language，输出 baidu.com c++
#include<iostream>
#include<vector>
#include<string>
#include<unordered_map>
using namespace std;
int main() {
string str;
getline(cin, str);
unordered_map<string, string> mmap;
//字符分割
for (int i = 0; i < str.size(); i++) {
int start = i;
while (start < str.size() && str[start] != '=') {
start++;
}
string str2 = str.substr(i, start - i);
int start2 = start + 1;
while (start2 < str.size() && str[start2] != ',') {
start2++;
}
string str3 = str.substr(start + 1 , start2 - start - 1);
i = start2;
//此处说相同的key取后者的value，应该直接替代是没有问题的
mmap[str2] = str3;
}
//输入验证
int n;
cin >> n;
string str4;
vector<string> vec;
while (n > 0 && cin >> str4) {
vec.push_back(str4);
n--;
}
for (string& strTmp : vec) {
if (mmap.count(strTmp) >= 1) {
cout << mmap[strTmp] << endl;
}
else {
cout << "EMPTY" << endl;
}
}
return 0;
}
美味值数组
给你一个每一天糖果的美味值数组，只能隔天吃，但也可以反悔，有K次反悔机会
- 思路：先用打家劫舍的方法，然后对没有选的取k个最大值
#include<iostream>
#include<vector>
#include<string>
#include<unordered_map>
#include<queue>
using namespace std;
int maxTaste(int k, vector<int>& vec) {
int len = vec.size();
vector<int> dp(len);
dp[0] = vec[0];
if (len == 1) {
return dp[0];
}
vector<bool> used(len, false);
if (len >= 2) {
dp[1] = max(dp[0], vec[1]);
if (len == 2) {
if (k > 0) {
return vec[0] + vec[1];
}
else {
return dp[1];
}
}
}
for (int i = 2; i < len; i++) {
dp[i] = max(dp[i - 2] + vec[i], dp[i - 1]);
}
//判断最后一个选了没
bool jus;
if (dp[len - 3] + vec[len - 1] > dp[len - 2]) {
jus = true;
}
else {
jus = false;
}
priority_queue<int, vector<int>, less<int>> pq;
if (!jus) {
for (int i = len - 1; i > 0; i = i - 2) {
pq.push(vec[i]);
}
}
else {
for (int i = len - 2; i > 0; i = i - 2) {
pq.push(vec[i]);
}
}
int res = dp[len - 1];
for (int i = 0; i < k; i++) {
res += pq.top();
pq.pop();
}
return res;
}
int main() {
//反悔次数
int k;
cin >> k;
//输入美味值
int n; //天数
cin >> n;
vector<int> vec;
int num;
while (n > 0 && cin >> num) {
vec.push_back(num);
n--;
}
cout << maxTaste(k, vec) << endl;
return 0;
}
0-1背包问题
n块巧克力板，边长为a[i], 重量为a[i]*a[i], m 个背包， 可以装重量为b[i]， 求每个背包最多可以装多少？
- 思路： 可以对巧克力板按重量从小到大排序，前缀和即可
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
using namespace std;
int large(vector<int>& a, int b) {
int sum = 0;
int len = a.size();
int i;
for (i = 0; i < len; i++) {
sum += a[i];
if (sum > b) {
break;
}
}
return i;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> a, b;
int ins;
while (n > 0 && cin >> ins) {
a.push_back(ins * ins);
n--;
}
while (m > 0 && cin >> ins) {
b.push_back(ins);
m--;
}
sort(a.begin(), a.end());
for (int tmp : b) {
cout << large(a, tmp)<< " ";
}
cout << endl;
return 0;
}
用O(n)写一个数组的第K大数
快速选择算法的基本思想是通过每次选取一个基准元素，将数组分为两个部分，小于基准元素的部分和大于基准元素的部分。然后根据基准元素所在位置和K的关系，决定在哪个部分继续查找
#include <iostream>
#include <vector>
// 快速选择算法
int quickSelect(std::vector<int>& nums, int left, int right, int k) {
// 选取基准元素
int pivot = nums[left];
int i = left + 1;
int j = right;
// 将大于基准元素的数移到右侧，小于基准元素的数移到左侧
while (i <= j) {
if (nums[i] < pivot && nums[j] > pivot) {
std::swap(nums[i], nums[j]);
i++;
j--;
}
if (nums[i] >= pivot) {
i++;
}
if (nums[j] <= pivot) {
j--;
}
}
// 将基准元素放在正确的位置
std::swap(nums[left], nums[j]);
// 判断基准元素的位置与K的关系
int pos = j - left + 1;
if (pos == k) {
return nums[j];
}
else if (pos > k) {
return quickSelect(nums, left, j - 1, k);
}
else {
return quickSelect(nums, j + 1, right, k - pos);
}
}
// 找出数组的第K大数
int findKthLargest(std::vector<int>& nums, int k) {
int n = nums.size();
return quickSelect(nums, 0, n - 1, k);
}
int main() {
std::vector<int> nums = { 3, 1, 5, 2, 4 };
int k = 2;
int kthLargest = findKthLargest(nums, k);
std::cout << "第" << k << "大数是：" << kthLargest << std::endl;
return 0;
}
合并有序数组
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int p1=m-1;
int p2=n-1;
int tail=p1+p2+1;
int cur;
while(p1>=0||p2>=0){
if(p1==-1){
cur=nums2[p2--];
}
else if(p2==-1){
cur=nums1[p1--];
}
else if(nums1[p1]>nums2[p2]){
cur=nums1[p1--];
}
else{
cur=nums2[p2--];
}
nums1[tail--]=cur;
}
}
};
输入一堆数，每个数都是出现 4 次，只有一个数出现三次,找出这个数。时间复杂度 O(nlogn),空间复杂度 O(logn)
1）手撕快排再遍历
2）一直异或，最后异或的结果一定是那个数
#include<iostream>
#include<vector>
using namespace std;
//时间复杂度O（N）
int main() {
vector<int>nums{ 1,1,1,1,2,2,2,3,3,3,3,6,6,6,6,5,5,5,5};
int ans = nums[0];
for (int i = 1; i < nums.size(); i++) {
ans = ans ^ nums[i];
}
cout << ans << endl;
return 0;
}
手写生产者消费者模型
为应对系统的通信上消息收发的高耦合度，在接受和发送消息后设计一个缓存队列，并使用多线程生产者-消费者来进行收发解耦。避免通信上的拥堵情况。
class MyTest{
private:
std::deque<T> queue_; //缓存队列
size_t size_limit_; //缓存队列大小的限制
std::mutex lock_; //互斥锁
std::condition_variable empty_, full_; //并发条件变量类
std::atomic<int> producer_num_; //生产者数量
};
实现思路是：当缓存队列满的时候，生产者将被挂起，直到队列重新拥有空间。但缓存队列为空时，消费者线程将被挂起，直到有“商品”被放入队列之中。
void Productor(T& item) {
{
std::unique_lock<std::mutex> lk(lock_); //加锁防止冲突
while (queue_.size() >= size_limit_) {
full_.wait(lk);
}
queue_.emplace_back(item);
}
empty_.notify_one();
}
full_.wait(lk)在queue队列满时将会把Productor挂起，直到queue有空间放入新的item。notify_one方法任意从WAITTING状态的线程中挑选一个进行通知，使得调用wait()方法的线程从等待队列移入到同步队列中，等待有机会再一次获取到锁，从而使得调用wait()方法的线程能够从wait()方法处退出。
bool Consumer(T& item) {
{
std::unique_lock<std::mutex> lk(lock_);
while (queue_.empty() && (producer_num_ != 0)) {
empty_.wait(lk);
}
if (queue_.empty() && (producer_num_ == 0)) {
return false;
} else {
item = std::move(queue_.front());
queue_.pop_front();
full_.notify_one();
return true;
}
}
}
同理，empty_.wait(lk)会在生产者数量为0或者队列queue为空的时候，将Consumer挂起。直到有商品进入到队列中。这样就可以实现一个简单的生产者消费者。
二叉树层序遍历
vector<vector<int>> levelOrder(TreeNode*root) {
queue<TreeNode*>que;
if(root==NULL) return root;
que.push(root);
vector<vector<int>>ans;
while(!que.empty()){
int n=que.size();
vector<int>path;
for(int i=0;i<n;i++){
TreeNode*node=que.front();
que.pop_back();
path.push_back(node->val);
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
ans.push_back(path);
}
return ans;
}
输入高维张量，返回shape
import numpy as np
def get_shape(tensor):
shape = np.shape(tensor)
return shape
# 示例输入一个3维张量
tensor = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
shape = get_shape(tensor)
print(shape)
#include <iostream>
#include <vector>
using namespace std;
template<typename T>
vector<size_t> getShape(const vector<T>& tensor) {
vector<size_t> shape;
size_t size = tensor.size();
while (size > 0) {
shape.push_back(size);
size /= tensor[0].size();
}
return shape;
}
int main() {
vector<vector<vector<int>>> tensor{
{{1, 2}, { 3, 4 }},
{ {5, 6}, {7, 8} }
};
vector<size_t> shape = getShape(tensor);
cout << "Shape: ";
for (size_t dim : shape) {
std::cout << dim << " ";
}
cout << std::endl;
return 0;
}
GPU内存结构
- 全局内存（Global Memory）：全局内存是GPU中最大的内存池，通常具有较大的容量。它用于存储核心数据结构、变量和计算结果等。全局内存对于所有线程可见，但相对于其他内存层级而言，它的访问速度较慢。
- 共享内存（Shared Memory）：共享内存是位于GPU的多处理器（Multiprocessor）中的每个线程块（Thread Block）之间共享的内存区域。它的访问速度非常快，可以在同一线程块的线程之间共享数据。共享内存主要用于线程之间的通信和协作，以提高性能。
- 常量内存（Constant Memory）：常量内存用于存储在执行期间不会发生改变的常量数据。它在访问速度上比全局内存快，但容量较小。常量内存对于所有线程可见，可以通过缓存机制提高访问效率。
- 纹理内存（Texture Memory）：纹理内存是专门用于图形渲染的内存区域，具有高速缓存和过滤器等功能。它主要用于存储纹理数据，并提供一些特殊的访问方式，如双线性插值和边界处理等。
- 寄存器文件（Register File）：寄存器文件是GPU中每个线程的私有内存空间。它用于存储线程的局部变量、中间计算结果和函数调用参数等。寄存器的访问速度非常快，但容量有限。对于某些计算密集型任务，寄存器的使用可能需要精心管理以避免资源耗尽。
CUDA三维结构好还是二维好
CUDA（Compute Unified Device Architecture）是NVIDIA提供的用于GPU编程的并行计算平台和编程模型。在CUDA中，既可以使用二维结构（二维线程块和二维网格）也可以使用三维结构（三维线程块和三维网格）。选择使用二维还是三维结构取决于问题的特性和并行计算的需求。
二维结构：
- 二维结构适用于处理具有二维或类似矩阵的数据结构。例如，图像处理中的像素数据可以组织为二维数组，因此使用二维结构可以方便地处理图像。
- 二维结构可以更好地利用数据的空间局部性。相邻的线程可以访问相邻的数据，这有助于减少全局内存访问和数据传输的次数，提高数据访问的效率。
三维结构： - 三维结构适用于处理具有三维特性的数据结构，例如体积数据或具有复杂三维结构的数据集。
- 使用三维结构可以更好地描述和组织三维数据，提高代码的可读性和可维护性。
- 在某些情况下，三维结构可以提供更好的并行计算的均匀性和负载平衡，特别是当问题具有三维的均匀性或对称性时。
总体而言，选择二维结构还是三维结构应根据问题的特性、数据的组织方式以及并行计算的需求来决定。如果问题可以自然地映射到二维结构，并且能够充分利用二维数据的空间局部性，那么二维结构可能更合适。如果问题具有三维特性或需要更好的均匀性和负载平衡，则可以考虑使用三维结构。在实际使用中，可以通过实验和性能分析来确定最适合问题的结构。
tensor core 了解吗
Tensor Core提供了高度优化的矩阵乘法和累积运算功能，能够在相对较短的时间内执行大规模矩阵运算，从而加速深度学习模型的训练和推理过程。
Tensor Core的主要特点包括：
- 数值精度：Tensor Core支持半精度浮点数（FP16）运算，它将浮点运算的计算精度降低一半，但同时大大增加了计算性能。在深度学习中，使用半精度计算通常可以满足训练和推理的准确性要求，能够显著提升计算速度。
- 矩阵乘法：Tensor Core使用特定的算法和硬件电路来加速矩阵乘法运算，尤其是小批量（mini-batch）矩阵乘法。它能够同时执行多个矩阵乘法操作，并且支持半精度累积运算，使得在一个时钟周期内可以完成更多的计算。
- 混合精度计算：Tensor Core可以与其他精度计算单元结合使用，如32位浮点数（FP32）和整数计算单元。这种混合精度计算的方法能够在保持准确性的同时提高计算性能，常用于深度学习的训练和推理过程。
Tensor Core广泛应用于深度学习框架和库，如TensorFlow和PyTorch等，以加速深度神经网络的计算。它可以显著提高模型训练的速度，并在一定程度上降低对计算资源的需求。然而，使用Tensor Core需要特定的软件支持和配置，以确保正确地利用它的性能优势。
ReduceSum怎么优化
- 数据布局优化：调整数据的布局方式，以便在内存访问和数据传输方面更加高效。例如，优化数据的连续性和缓存友好性，可以利用缓存和向量化指令集提高访问效率。
- 并行化：使用并行计算技术，如线程、向量化和GPU并行处理等，将ReduceSum操作分布到多个计算单元上并发执行，以提高计算效率。
3.** 数据复用**：尽可能地复用数据，减少不必要的读取和写入操作。可以通过共享内存、寄存器或缓存等机制来缓存中间计算结果，以减少数据的重复读取和写入。 - 剪枝和分解：对于大规模ReduceSum操作，可以考虑使用剪枝和分解等技术将其分解为更小的子任务，以降低每个子任务的计算负载，并充分利用并行性。
- 异步计算：使用异步计算技术，如CUDA流或异步任务队列，将ReduceSum操作与其他计算任务重叠，以充分利用计算和数据传输之间的隐藏延迟，提高整体性能。
- 内存访问优化：通过合理地利用局部性原则、数据对齐和访问模式等技术，优化内存访问方式，减少数据传输次数和延迟，提高数据吞吐量。
- 分级存储：对于大规模ReduceSum操作，可以使用分级存储策略，将数据分为多个层级，并使用不同的存储介质来适应不同的访问需求。例如，结合全局内存、共享内存和寄存器等多级存储来提高性能。
- 算法选择：根据实际需求，选择适合的ReduceSum算法。不同的算法可能有不同的计算复杂度和内存访问模式，选择合适的算法可以提高性能。
异构设备内存局部性怎么优化
- 内存访问模式优化：调整数据的访问模式，以提高内存局部性。例如，尽量保证线程对内存的访问是连续的、对齐的，避免随机的、不规则的内存访问。
- 数据布局优化：重组数据的存储方式，以提高内存局部性。例如，将相关的数据项存储在相邻的内存位置，或者使用数据结构和算法来组织数据，以充分利用局部性原则。
- 数据复用：尽量复用已经从内存加载到高速缓存的数据，减少对主存的访问。可以使用缓存、共享内存或寄存器等层级存储来存储中间计算结果，以避免重复的内存访问。
- 数据预取：利用硬件的数据预取机制，提前将需要使用的数据从主存加载到高速缓存，以减少访问延迟。可以使用编译器指令、预取指令或手动编码来控制数据的预取行为。
- 空间局部性优化：利用数据的空间局部性原则，以减少数据的移动和传输。例如，通过使用局部变量、循环展开、数据重用等技术来减少内存的读写操作。
- 访问模式分析和优化：通过对代码进行访问模式分析，了解内存访问的模式和特点，进而针对性地进行优化。可以使用工具、分析器或性能剖析器来帮助确定访问模式和性能瓶颈，并针对性地进行优化。
- 数据压缩和存储优化：在某些情况下，可以使用数据压缩技术来减少内存占用和传输带宽。通过压缩算法、数据压缩库或自定义的数据存储方案等方式，将数据压缩后存储在内存中，然后在需要使用时进行解压缩。
K 个一组翻转链表
class Solution {
public:
// 翻转一个子链表，并且返回新的头与尾
pair<ListNode*, ListNode*> myReverse(ListNode* head, ListNode* tail) {
ListNode* prev = tail->next;
ListNode* p = head;
while (prev != tail) {
ListNode* nex = p->next;
p->next = prev;
prev = p;
p = nex;
}
return {tail, head};
}
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode* hair = new ListNode(0);
hair->next = head;
ListNode* pre = hair;
while (head) {
ListNode* tail = pre;
// 查看剩余部分长度是否大于等于 k
for (int i = 0; i < k; ++i) {
tail = tail->next;
if (!tail) {
return hair->next;
}
}
ListNode* nex = tail->next;
// 这里是 C++17 的写法，也可以写成
// pair<ListNode*, ListNode*> result = myReverse(head, tail);
// head = result.first;
// tail = result.second;
tie(head, tail) = myReverse(head, tail);
// 把子链表重新接回原链表
pre->next = head;
tail->next = nex;
pre = tail;
head = tail->next;
}
return hair->next;
}
};
最长回文子串：中心扩散法
class Solution {
public:
pair<int, int> expandAroundCenter(const string& s, int left, int right) {
while (left >= 0 && right < s.size() && s[left] == s[right]) {
--left;
++right;
}
return {left + 1, right - 1};
}
string longestPalindrome(string s) {
int start = 0, end = 0;
for (int i = 0; i < s.size(); ++i) {
auto [left1, right1] = expandAroundCenter(s, i, i);
auto [left2, right2] = expandAroundCenter(s, i, i + 1);
if (right1 - left1 > end - start) {
start = left1;
end = right1;
}
if (right2 - left2 > end - start) {
start = left2;
end = right2;
}
}
return s.substr(start, end - start + 1);
}
};
字符串首次出现3次的字符
哈希表就行，遍历字符串，存放在map中，并判断value==3就返回key
#include<iostream>
#include<unordered_map>
using namespace std;
string str;
cin>>str;
unordered_map<char,int>um;
for(auto &i:str){
um[i]++;
if(i.second==3){
cout<<i.first<<endl;
}
}
数组中只出现一次的数字
//时间复杂度O(n)
//空间复杂度O(n)
#include<iostream>
#include<unordered_map>
#include<vector>
using namespace std;
class Solution {
public:
int singleNumber(vector<int>& nums) {
unordered_map<int,int>mp;
int ans=0;
for(auto &i:nums){
mp[i]++;
}
for(auto &i:mp){
if(i.second==1){
ans=i.first;
}
}
//for(auto &[key,value]:mp){
// if(value==1){
// ans=key;
// break;
// }
//}
return ans;
}
};
合并2个有序数组
法一排序
将nums2放到nums1中，直接排序
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
for(int i=0;i<n;i++){
nums1[m++]=nums2[i];
}
sort(nums1.begin(),nums1.end());
}
};
法二，双指针
逆向双指针，尾部覆盖
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int p1=m-1,p2=n-1;
int tail=m+n-1;
while(p1>=0||p2>=0){
if(p1==-1){
nums1[tail--]=nums2[p2--];
}
else if(p2==-1){
nums1[tail--]=nums1[p1--];
}
else if(nums1[p1]<nums2[p2]){
nums1[tail--]=nums2[p2--];
}
else{
nums1[tail--]=nums1[p1--];
}
}
}
};
435.不重叠区间
先计算不重叠的区间数，然后用总的区间数—重叠的=要去掉的，记得自定义排序规则
class Solution {
public:
/// static bool cmp(vector<int>&a,vector<int>&b){
// return a[1]<b[1];
//}
int eraseOverlapIntervals(vector<vector<int>>& intervals) {
//sort(intervals.begin(),intervals.end(),cmp);
sort(intervals.begin(),intervals.end(),[](const auto &a,const auto &b){
return a[1]<b[1];
});
int count=1;
int right=intervals[0][1];
for(int i=1;i<intervals.size();i++){
if(intervals[i][0]>=right){
count++;
right=intervals[i][1];
}
}
return intervals.size()-count;
}
};
73.矩阵置零
2个标记数组，如果有元素为0，元素所在的行列所对应的标记数组的位置置true,用标记数组更新原数组
class Solution {
public:
void setZeroes(vector<vector<int>>& matrix) {
int m=matrix.size();
int n=matrix[0].size();
vector<bool>row(m),col(n);
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(!matrix[i][j]){
row[i]=col[j]=true;
}
}
}
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(row[i]||col[j]){
matrix[i][j]=0;
}
}
}
}
};
分割字符串,知道字符数量
输入一个字符串,求[“xiao”,“mi”]的组和有多少种
比如 输入：“I love xiaomi, I think mi com is the best"
输出：2
计算输入字符串中指定子字符串组的数量
#include <iostream>
#include <vector>
#include <string>
//s输入字符串
int countSubstringGroups(const std::string& s, const std::vector<std::string>& substrings) {
int count = 0;
size_t startIndex = 0;
while (true) {
bool found = false;
//遍历目标串
for (const auto& substring : substrings) {
size_t index = s.find(substring, startIndex);
if (index != std::string::npos) {
found = true;
startIndex = index + substring.length();
break;
}
}
if (!found) {
break;
}
bool allNotFound = true;
for (const auto& substring : substrings) {
if (s.find(substring, startIndex) != std::string::npos) {
allNotFound = false;
break;
}
}
if (allNotFound) {
count++;
}
}
return count;
}
int main() {
// 输入字符串
std::string inputStr = "I love xiaomi, I think mi com is the best";
// 目标子字符串列表
std::vector<std::string> targetSubstrings = {"xiao", "mi"};
// 计算组数
int result = countSubstringGroups(inputStr, targetSubstrings);
// 输出结果
std::cout << result << std::endl;
return 0;
}
划分3*3矩阵
有一个m*n的字符矩阵，
要求：3*3的连续子矩阵里面x,a,o,m至少出现1次，i至少出现2次
求这样的3*3的矩阵有多少？
比如输入4*4的话
x i a q
o i m e
x a i c
c a d f
输出结果为2，有2个符合条件的连续子矩阵
x i a
o i m
x a i
o i m
x a i
c a d
#include <iostream>
#include <vector>
using namespace std;
bool isValidSubmatrix(const vector<vector<char>>& matrix, int startRow, int startCol) {
int count_x = 0, count_a = 0, count_o = 0, count_m = 0, count_i = 0;
for (int i = startRow; i < startRow + 3; ++i) {
for (int j = startCol; j < startCol + 3; ++j) {
char currentChar = matrix[i][j];
if (currentChar == 'x') count_x++;
else if (currentChar == 'a') count_a++;
else if (currentChar == 'o') count_o++;
else if (currentChar == 'm') count_m++;
else if (currentChar == 'i') count_i++;
else{
continue;
}
}
}
return (count_x >= 1 && count_a >= 1 && count_o >= 1 && count_m >= 1 && count_i >= 2);
}
int countSubmatrices(const vector<vector<char>>& matrix) {
int m = matrix.size();
int n = matrix[0].size();
int count = 0;
for (int i = 0; i < m - 2; ++i) {
for (int j = 0; j < n - 2; ++j) {
if (isValidSubmatrix(matrix, i, j)) {
count++;
}
}
}
return count;
}
int main() {
// 示例 4x4 的字符矩阵
vector<vector<char>> matrix = {
{'x', 'i', 'a', 'q'},
{'o', 'i', 'm', 'e'},
{'x', 'a', 'i', 'c'},
{'c', 'a', 'd', 'f'}
};
int result = countSubmatrices(matrix);
cout << "满足条件的3x3子矩阵数量为: " << result << endl;
return 0;
}
42.接雨水
动态规划
1）统计每个下标左边的最大值，正向遍历
2）统计每个下标右边的最大值，反向遍历
3）计算每个下标的储水量，累加
//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
int trap(vector<int>& height) {
if(height.size()<=2) return 0;
vector<int>leftHeight(height.size(),0);
vector<int>rightHeight(height.size(),0);
int size=rightHeight.size();
leftHeight[0]=height[0];
for(int i=1;i<size;i++){
leftHeight[i]=max(height[i],leftHeight[i-1]);
}
rightHeight[size-1]=height[size-1];
for(int i=size-2;i>=0;i--){
rightHeight[i]=max(height[i],rightHeight[i+1]);
}
int sum=0;
for(int i=0;i<size;i++){
int h=min(leftHeight[i],rightHeight[i])-height[i];
if(h>0) sum+=h;
}
return sum;
}
};
有序链表
法一，先放到数组
class Solution
{
public:
ListNode* sortList(ListNode* head)
{
if(head==nullptr) return head;
vector<ListNode*>v;
ListNode*cur=head;
while(cur)
{
v.push_back(cur);
cur=cur->next;
}
sort(v.begin(),v.end(),[](ListNode*a,ListNode*b){return a->val<b->val;});
cur=v[0];
for(int i=1;i<v.size();++i)
{
cur->next=v[i];
cur=v[i];
}
cur->next=nullptr;
return v[0];
}
};
法二：合并2个有序链表，中点划分链表
class Solution
{
public:
ListNode* sortList(ListNode* head)
{
return sortList(head,nullptr);
}
ListNode*sortList(ListNode*head,ListNode*tail)
{
if(head==nullptr)
{
return head;
}
if(head->next==tail)
{
head->next=nullptr;
return head;
}
//找中点，以中点位2分界拆分成2个子链表，快慢指针
ListNode*slow=head,*fast=head;
while(fast!=tail)
{
slow=slow->next;
fast=fast->next;
if(fast!=tail)
{
fast=fast->next;
}
}
ListNode*mid=slow;
return merge(sortList(head,mid),sortList(mid,tail));
}
//合并两个有序链表
ListNode*merge(ListNode*head1,ListNode*head2)
{
ListNode*dummyHead=new ListNode(0);
ListNode*temp=dummyHead,*temp1=head1,*temp2=head2;
while(temp1!=nullptr&&temp2!=nullptr)
{
if(temp1->val<=temp2->val)
{
temp->next=temp1;
temp1=temp1->next;
}
else
{
temp->next=temp2;
temp2=temp2->next;
}
temp=temp->next;
}
if(temp1!=nullptr)
{
temp->next=temp1;
}
if(temp2!=nullptr)
{
temp->next=temp2;
}
return dummyHead->next;
}
};
一个数恰好等于它的因子之和
比如6=1+2+3，称为完数，问1-10000有多少个完数
#include <iostream>
#include <vector>
//找因子
std::vector<int> findFactors(int num) {
std::vector<int> factors = {1}; // 1 是所有正整数的因子
for (int i = 2; i <= num / 2; ++i) {
if (num % i == 0) {
factors.push_back(i);
}
}
return factors;
}
//找出所有完数
std::vector<int> findPerfectNumbers(int limit) {
std::vector<int> perfectNumbers;
for (int num = 2; num <= limit; ++num) {
if (std::find(perfectNumbers.begin(), perfectNumbers.end(), num) != perfectNumbers.end()) {
continue; // 避免重复计算已经找到的完数
}
std::vector<int> factors = findFactors(num);
int sum = 0;
for (int factor : factors) {
sum += factor;
}
if (sum == num) {
perfectNumbers.push_back(num);
}
}
return perfectNumbers;
}
int main() {
int limit = 10000;
std::vector<int> perfectNumbersList = findPerfectNumbers(limit);
std::cout << "在1到" << limit << "之间有" << perfectNumbersList.size() << "个完数，它们分别是：" << std::endl;
for (int num : perfectNumbersList) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
大数相减
// 函数用于模拟字符串相加，包括进位处理
string addStrings(string num1, string num2) {
int carry = 0;
string result;
// 让两个字符串等长，短的字符串前面补0
int len = max(num1.length(), num2.length());
num1 = string(len - num1.length(), '0') + num1;
num2 = string(len - num2.length(), '0') + num2;
for (int i = len - 1; i >= 0; i--) {
int digit1 = num1[i] - '0';
int digit2 = num2[i] - '0';
int sum = digit1 + digit2 + carry;
carry = sum / 10;
result += to_string(sum % 10);
}
if (carry > 0) {
result += to_string(carry);
}
reverse(result.begin(), result.end()); // 反转结果字符串
return result;
}
浮点数相加
//字符串转浮点stod
//自定义函数用于将浮点数字符串转换为 double
double stringToDouble(const std::string& str) {
double result = 0.0;
bool isNegative = false;
bool isFraction = false;
double fractionMultiplier = 0.1;
for (char ch : str) {
if (ch == '-') {
isNegative = true;
} else if (ch == '.') {
isFraction = true;
} else {
if (isFraction) {
result += (ch - '0') * fractionMultiplier;
fractionMultiplier *= 0.1;
} else {
result = result * 10 + (ch - '0');
}
}
}
return isNegative ? -result : result;
}
统计元音字母个数
对偶性质
class Solution {
public:
long long countVowels(string word) {
int n = word.size();
unordered_set<char> vowels = {'a', 'e', 'i', 'o', 'u'};
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (vowels.count(word[i])) {
ans += (long long)(i + 1) * (n - i);
}
}
return ans;
}
};
双链表模拟
假设双链表把一个 q 所指新结点作为非空双向链表中的 p 所指结点的前驱结点插入到该双链表中，算法步骤。
q->Link=p->prev;
p->Link=q;
q->Rink=p;
q->Link->Rlink=q;
输入的句子使用find函数找出NiuNiu，没有则输出-1；限定Python语言
input_sentence = input("请输入句子：") # 获取用户输入的句子
# 使用find方法查找子字符串
index = input_sentence.find("NiuNiu")
if index != -1:
print("NiuNiu 在句子中的索引是:", index)
else:
print("NiuNiu 未在句子中找到")
字符串排序
2.给定几个字符串，请你分类，对于同一类字符串，可以通过N次交换其中的元素变为一样的，如ABCD和CDBA，不限定交换次数；
输入
4
ABCD
BCDA
ACBD
CDAB
输出
1
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
int classifyStrings(std::vector<std::string> strings) {
std::set<std::string> sortedStrings;
for (const std::string& str : strings) {
std::string sortedStr = str;
std::sort(sortedStr.begin(), sortedStr.end());
sortedStrings.insert(sortedStr);
}
return sortedStrings.size();
}
int main() {
int n;
std::cin >> n;
std::vector<std::string> strings(n);
for (int i = 0; i < n; i++) {
std::cin >> strings[i];
}
int result = classifyStrings(strings);
std::cout << result << std::endl;
return 0;
}
105.岛屿的最大面积
class Solution {
int dfs(vector<vector<int>>& grid, int cur_i, int cur_j) {
if (cur_i < 0 || cur_j < 0 || cur_i == grid.size() || cur_j == grid[0].size() || grid[cur_i][cur_j] != 1) {
return 0;
}
grid[cur_i][cur_j] = 0;
int di[4] = {0, 0, 1, -1};
int dj[4] = {1, -1, 0, 0};
int ans = 1;
for (int index = 0; index != 4; ++index) {
int next_i = cur_i + di[index], next_j = cur_j + dj[index];
ans += dfs(grid, next_i, next_j);
}
return ans;
}
public:
int maxAreaOfIsland(vector<vector<int>>& grid) {
int ans = 0;
for (int i = 0; i != grid.size(); ++i) {
for (int j = 0; j != grid[0].size(); ++j) {
ans = max(ans, dfs(grid, i, j));
}
}
return ans;
}
};
641.双端队列模拟
class MyCircularDeque {
private:
vector<int> elements;
int rear, front;
int capacity;
public:
MyCircularDeque(int k) {
capacity = k + 1;
rear = front = 0;
elements = vector<int>(k + 1);
}
bool insertFront(int value) {
if (isFull()) {
return false;
}
front = (front - 1 + capacity) % capacity;
elements[front] = value;
return true;
}
bool insertLast(int value) {
if (isFull()) {
return false;
}
elements[rear] = value;
rear = (rear + 1) % capacity;
return true;
}
bool deleteFront() {
if (isEmpty()) {
return false;
}
front = (front + 1) % capacity;
return true;
}
bool deleteLast() {
if (isEmpty()) {
return false;
}
rear = (rear - 1 + capacity) % capacity;
return true;
}
int getFront() {
if (isEmpty()) {
return -1;
}
return elements[front];
}
int getRear() {
if (isEmpty()) {
return -1;
}
return elements[(rear - 1 + capacity) % capacity];
}
bool isEmpty() {
return rear == front;
}
bool isFull() {
return (rear + 1) % capacity == front;
}
};
141.环形链表
判断是否有环
class Solution {
public:
bool hasCycle(ListNode *head) {
ListNode*slow=head,*fast=head;
while(fast&&fast->next){
slow=slow->next;
fast=fast->next->next;
if(slow==fast){
return true;
}
}
return false;
}
};
142.环形链表 II
判断环的位置
相遇之后，slow指针回到出发点，一起走就行
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode*fast=head,*slow=head;
while(fast!=NULL&&fast->next!=NULL){
fast=fast->next->next;
slow=slow->next;
if(slow==fast){
ListNode*cur=slow;
ListNode*temp=head;
while(cur!=temp){
temp=temp->next;
cur=cur->next;
}
return temp;
}
}
return NULL;
}
};
怎么判断顺子5个
1）法一，先sort,然后遍历从第2个开始，看当前的是不是等于前一个+1
2）法二：放到set里面，判断最大值-最小值<5，且set的size=5
83.删除链表中的重复元素
1-2-2删除后为1-2
法一， 借助数组
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
vector<int>ans;
ListNode*cur=head;
while(cur){
ans.push_back(cur->val);
cur=cur->next;
}
ans.erase(unique(ans.begin(),ans.end()),ans.end());
ListNode*dummyNode=new ListNode(0);
ListNode*now=dummyNode;
for(int i=0;i<ans.size();i++){
now->next=new ListNode(ans[i]);
now=now->next;
}
return dummyNode->next;
}
};
法二，一次遍历
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
if(head==NULL||head->next==NULL){
return head;
}
ListNode*cur=head;
while(cur->next!=NULL){
if(cur->val==cur->next->val){
cur->next=cur->next->next;
}
else{
cur=cur->next;
}
}
return head;
}
};
82.删除排序链表中的重复元素 II
删除链表中所有重复出现过的数，即1-2-2删除后为1
//一次遍历
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
if (!head) {
return head;
}
ListNode* dummy = new ListNode(0, head);
ListNode* cur = dummy;
while (cur->next && cur->next->next) {
if (cur->next->val == cur->next->next->val) {
int x = cur->next->val;
while (cur->next && cur->next->val == x) {
cur->next = cur->next->next;
}
}
else {
cur = cur->next;
}
}
return dummy->next;
}
};
//哈希集合
class Solution
{
public:
ListNode* deleteDuplicates(ListNode* head)
{
unordered_set<int>us;
ListNode*s=head;
//将链表中的重复元素的值放入哈希集合
while(s!=NULL&&s->next!=NULL)
{
if(s->val==s->next->val)
us.insert(s->val);
s=s->next;
}
//遍历链表，与哈希集合比较，重复则删除
ListNode* prehead=new ListNode(-1);
prehead->next=head;
ListNode*pre=prehead;
s=head;
while(s!=NULL)
{
if(us.find(s->val)==us.end())//没有重复结点
{
s=s->next;
pre=pre->next;
}
else
{
pre->next=s->next;
s=s->next;
}
}
return prehead->next;
}
};
已经排好序的数组，找两个和为num的数字
//二分查找
//数组中的元素最多遍历一次，时间复杂度为 O(n*log(n))。
//只使用了两个额外变量，空间复杂度为 O(1)。
class Solution
{
public:
vector<int> twoSum(vector<int>& numbers, int target)
{
for (int i=0;i<numbers.size();++i)
{
int low=i+1,high=numbers.size()-1; //细节i+1
while(low<=high)
{
int mid=low+(high-low)/2;
if(numbers[mid]==target-numbers[i])
{
return {i+1,mid+1};
}
else if(numbers[mid]>target-numbers[i])
{
high=mid-1;
}
else
{
low=mid+1;
}
}
}
return {-1,-1};
}
};
补充知识
set_union并集
求两个有序序列的并集，合并结果包含所有的不重复元素，并拷贝到一个新的序列，前提是这两个序列的排序规则一样。
set_intersection交集
求两个有序序列的交集，合并结果是两个集合重合的元素，并拷贝到一个新的序列，前提是这两个序列的排序规则一样。
set_difference差集
求两个有序序列的差集，合并结果是在第一个集合中存在而在第二个集合中不存在的元素，并拷贝到一个新的序列，前提是这两个序列的排序规则一样。
set_symmetric_difference异或集
求两个有序序列的异或集，合并结果是两个序列合并后去除重合的元素，并拷贝到一个新的序列，前提是这两个序列的排序规则一样。
