cpp笔试常见的算法

KMP算法

一个人能走的多远不在于他在顺境时能走的多快，而在于他在逆境时多久能找到曾经的自己！

#include <iostream>
#include <vector>
using namespace std;
vector<int> get_next(string p) {
    int i = 1, n = p.size(), len = 0;
    vector<int> next(n);
    while (i < n) {
        if (p[len] == p[i]) {
            len++;
            next[i] = len;
            i++;
        } else if (len == 0) {
            i++;
        } else {
            len = next[len - 1];
        }
    }
    return next;
}
vector<int> kmp(string p, string text) {
    int n = text.size(), i = 0, j = 0, size = p.size();
    vector<int> ans;
    auto next = get_next(p);
    while (i < n) {
        if (text[i] == p[j]) {
            i++;
            j++;
        } else if (j == 0) {
            i++;
        } else {
            j = next[j - 1];
        }
        if (j == size) {
            ans.push_back(i - j);
            j = next[j - 1];
        }
    }
    return ans;
}
int main() {
    string s = "ABABDABACDABABCABCABCEABABC";
    string p = "ABABC";
    auto nums = kmp(p, s);
    for (auto& i : nums) {
        cout << i << " ";
    }
    cout << endl;
    return 0;
}

Floyd算法

#include <limits.h>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int finite = 1000000;
void floyd(vector<vector<int>>& g) {
    int n = g.size();
    for (int k = 0; k < n; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (g[i][k] != finite && g[k][j] != finite) {
                    g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
                }
            }
        }
    }
}

int main() {
    int n;
    cin >> n;
    vector<vector<int>> graph(n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int tmp;
            cin >> tmp;
            if (tmp == 0) {
                tmp = finite;
            }
            graph[i].push_back(tmp);
        }
    }
    floyd(graph);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) {
                cout << 0;
            } else if (graph[i][j] == finite) {
                cout << -1;
            } else {
                cout << graph[i][j];
            }
            if (j != n - 1) {
                cout << " ";
            }
        }

        cout << endl;
    }
    return 0;
}

例题

Dijkstra算法

#include <iostream>
#include <vector>
using namespace std;
const int finite = 100000;
class Edge {
   public:
    int to, weight;
    Edge(int t, int w) : to(t), weight(w) {}
};
vector<int> dijkstra(vector<vector<Edge>>& g, int start) {
    int n = g.size();
    vector<int> visit(n), dist(n, finite);
    dist[start] = 0;
    for (int i = 0; i < n; i++) {
        int u = -1;
        for (int j = 0; j < n; j++) {
            if (!visit[j] && (u == -1 || dist[j] < dist[u])) {
                u = j;
            }
        }
        if (u == -1 || dist[u] == finite) {
            break;
        }
        visit[u] = 1;
        for (auto edge : g[u]) {
            auto to = edge.to, weight = edge.weight;
            if (!visit[to] && dist[to] > dist[u] + weight) {
                dist[to] = dist[u] + weight;
            }
        }
    }
    return dist;
}
int main() {
    int n, s;
    cin >> n >> s;
    vector<vector<Edge>> g(n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int tmp;
            cin >> tmp;
            if (tmp != 0) {
                g[i].push_back({j, tmp});
            }
        }
    }
    auto dist = dijkstra(g, s);
    for (int i = 0; i < n; i++) {
        if (i == s) {
            continue;
        }
        if (dist[i] == finite) {
            cout << -1;
        } else {
            cout << dist[i];
        }
        cout << " ";
    }
    return 0;
}

例题

归并排序

#include <iostream>
#include <vector>
using namespace std;
void merge(vector<int>& nums, int left, int mid, int right) {
    vector<int> tmp(right - left + 1);
    int cur = 0;
    int i = left, j = mid + 1;
    while (i <= mid && j <= right) {
        if (nums[i] < nums[j]) {
            tmp[cur] = nums[i];
            i++;
        } else {
            tmp[cur] = nums[j];
            j++;
        }
        cur++;
    }
    while (i <= mid) {
        tmp[cur] = nums[i];
        cur++;
        i++;
    }
    while (j <= right) {
        tmp[cur] = nums[j];
        cur++;
        j++;
    }
    for (int k = 0; k < tmp.size(); k++) {
        nums[left + k] = tmp[k];
    }
}
void help(vector<int>& nums, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        help(nums, left, mid);
        help(nums, mid + 1, right);
        merge(nums, left, mid, right);
    }
}

void mergeSort(vector<int>& nums) {
    help(nums, 0, nums.size() - 1);
}

int main() {
    
    vector<int> nums;
    for (int i = 0; i < 100; i++) {
        nums.push_back(rand() % 1000);
    }
    cout << "Before sorting:" << endl;
    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
    cout << endl;
    mergeSort(nums);
    cout << "After sorting:" << endl;
    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
    cout << endl;
    
}

快速排序

#include <iostream>
#include <vector>
using namespace std;

void sort(vector<int>& nums, int left, int right) {
    if (left >= right) {
        return;
    }
    auto l = left, r = right;
    auto pivot = nums[left];
    while (l < r) {
        while (l < r && pivot <= nums[r]) {
            r--;
        }
        while (l < r && pivot >= nums[l]) {
            l++;
        }
        swap(nums[l], nums[r]);
    }
    swap(nums[l], nums[left]);
    sort(nums, left, l - 1);
    sort(nums, l + 1, right);
}

void quickSort(vector<int>& nums) {
    sort(nums, 0, nums.size() - 1);
}

int main() {
    vector<int> nums;
    for (int i = 0; i < 100; i++) {
        nums.push_back(rand() % 1000);
    }
    cout << "Before sorting:" << endl;
    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
    cout << endl;
    quickSort(nums);
    cout << "After sorting:" << endl;
    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
    cout << endl;
}