leetcode
基础
二分查找
int search(vector<int>& nums, int target) {
int left = 0;
int right = nums.size()-1;
while(left <= right) {
int mid = left + (right-left)/2;
if(nums[mid] < target) {
left = mid+1;
} else if(nums[mid] > target) {
right = mid-1;
} else {
return mid;
}
}
return -1;
}
归并排序（merge sort）或者快速排序（quicksort）和基数排序（radix sort）nlogn
动态数组 扩容拷贝删除原有内存
利用两个队列实现一个栈，以及利用两个栈来实现一个队列
读取和写入文件，而且要知道如何生成随机数
void selectKItems(int stream[], int n, int k)
{
int i; // index for elements in stream[]
int reservoir[k];
for (i = 0; i < k; i++)
reservoir[i] = stream[i];
srand(time(NULL));
for (; i < n; i++)
{
int j = rand() % (i+1);
if (j < k)
reservoir[j] = stream[i];
}
printf("Following are k randomly selected items \n");
printArray(reservoir, k);
}
每个数均可以被分解成质数的和。
int countPrimes(int n) {
vector<bool> prime(n, true);
prime[0] = false, prime[1] = false;
for (int i = 0; i < sqrt(n); ++i) {
if (prime[i]) {
for (int j = i*i; j < n; j += i) {
prime[j] = false;
}
}
}
return count(prime.begin(), prime.end(), true);
}
位：bit = num & (1 << x); num ^= 1 << x; 等
数学：Cnk=n! / k!(n-k)! Cnk=Cn-1k+Cn-1k-1 Cnk=Cnn-k Ank=n!/(n-k)! Ann=n!
http://www.cs.trincoll.edu/~ram/cpsc110/inclass/conversions.html
树
广度优先搜索（breadth-first-search）、深度优先搜索（depth-first-search），以及中序遍历、后序遍历和前序遍历之间的差异。
堆总能找到最大值，但代价就是寻找其余任何一个值所需的时间都是O(n)。插入和删除所需的时间依然是O(logn)
字典树
二叉树-》二叉搜索树=》平衡树/红黑树 查找、插入和删除就能够在O(log n)html
排列
找下一个 https://leetcode.com/problems/next-permutation
void nextPermutation(vector<int>& nums) {
int n = nums.size(), k, l;
for (k = n - 2; k >= 0; k--) {
if (nums[k] < nums[k + 1]) {
break;
}
}
if (k < 0) {
reverse(nums.begin(), nums.end());
} else {
for (l = n - 1; l > k; l--) {
if (nums[l] > nums[k]) {
break;
}
}
swap(nums[k], nums[l]);
reverse(nums.begin() + k + 1, nums.end());
}
}
Anm
https://leetcode.com/problems/permutations-ii/
vector<vector<int>> permuteUnique(vector<int>& nums) {
vector<vector<int>> ret;
if(nums.empty()){
return ret;
}
sort(nums.begin(),nums.end()); //1.排序 每次第一个都会入，若是不排序 跳太重复会用不了
permuteInner(nums,0,ret);
return ret;
}
void permuteInner(vector<int> nums,int stable,vector<vector<int>>& ret) {
if(stable==nums.size()-1){
ret.push_back(nums);
return;
}
for(int j=stable;j<nums.size();j++){
//2.跳太重复
if(stable!=j&&nums[j]==nums[stable]){
continue;
}
//3.至关于前面j位已经排好，求j后面的排序组合，但前面j位能够是后面的任何一个。交换
swap(nums[stable],nums[j]);
permuteInner(nums,stable+1,ret);
}
}
Cmn 非重复node
vector<vector<int>> subsets(vector<int>& nums) {
vector<vector<int>> ret{{}};
ret.push_back(tmp);
for(int i=0;i<nums.size();i++){
subsetsInner(nums[i], ret);
}
return ret;
}
void subsetsInner(int num,vector<vector<int>>& ret){
int len=ret.size();
for(int i=0;i<len;i++){
vector<int> tmp=ret[i];
tmp.push_back(num);
ret.push_back(tmp);
}
}
Cmn 重复的排序c++
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
sort(nums.begin(),nums.end());
vector<vector<int>> ret{{}};
for(int i=0;i<nums.size();i++){
vector<int> tmp(1,nums[i]);
while(i<nums.size()-1&&nums[i+1]==nums[i]){
i++;
tmp.push_back(nums[i]);
}
subsetsWithDup2(tmp,ret);
}
return ret;
}
void subsetsWithDup2(vector<int>& nums,vector<vector<int>>& ret){
int len=ret.size();
for(int i=0;i<len;i++){
for(int j=1;j<=nums.size();j++){
vector<int> tmp=ret[i];
tmp.insert(tmp.end(),nums.begin(),nums.begin()+j);
ret.push_back(tmp);
}
}
}
可重复和算法
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
vector<vector<int>> ret;
vector<int> sret;
sort(candidates.begin(),candidates.end());
combinationSumInner(candidates,0,target,sret,ret);
return ret;
}
void combinationSumInner(vector<int>& candidates,int begin,int target,vector<int>& sret,vector<vector<int>>& ret){
for(int i=begin;i<candidates.size();i++){
if(target-candidates[i]>0){
sret.push_back(candidates[i]);
combinationSumInner(candidates,i,target-candidates[i],sret,ret);
sret.erase(sret.end()-1);
}else if(target-candidates[i]==0){
sret.push_back(candidates[i]);
ret.push_back(sret);
sret.erase(sret.end()-1);
}
}
}
不可重复和数组
void combinationSumInner(vector<int>& candidates,int begin,int target,vector<int>& sret,vector<vector<int>>& ret){
for(int i=begin;i<candidates.size();i++){
if(i>begin && candidates[i]==candidates[i-1]) continue; //去重复
if(target-candidates[i]>0&&(i<candidates.size()-1)){
sret.push_back(candidates[i]);
combinationSumInner(candidates,i+1,target-candidates[i],sret,ret); //前移
sret.erase(sret.end()-1);
}else if(target-candidates[i]==0){
sret.push_back(candidates[i]);
ret.push_back(sret);
sret.erase(sret.end()-1);
}
}
}
数字加和缓存
void combinationSumInner(int k,int begin,int n,vector<int>& sret,vector<vector<int>>& ret){
for(int i=begin;i<10;i++){
if(n-i>0&&(i<9)&&k>1){
sret.push_back(i);
combinationSumInner(k-1,i+1,n-i,sret,ret); //前移
sret.erase(sret.end()-1);
}else if(n-i==0&&k==1){
sret.push_back(i);
ret.push_back(sret);
sret.erase(sret.end()-1);
}
}
}
k-sum问题
转为一个和和k-1sum的问题。常规复杂度n^(k-1)
2-sum 首尾指针。或者一个hash 另外一个查加和
3-sum 一个for 两个首尾。只要后面的
4-sum 2个先缓存，再用2-sum的chahedom
链表
链表深拷贝
next和random两个不一样指针的拷贝
//把2插入到1中，
//l1->next->random = l1->random->next
RandomListNode *copyRandomList(RandomListNode *head) {
RandomListNode *newHead, *l1, *l2;
if (head == NULL) return NULL;
for (l1 = head; l1 != NULL; l1 = l1->next->next) {
l2 = new RandomListNode(l1->label);
l2->next = l1->next;
l1->next = l2;
}
newHead = head->next;
for (l1 = head; l1 != NULL; l1 = l1->next->next) {
if (l1->random != NULL) l1->next->random = l1->random->next;
}
for (l1 = head; l1 != NULL; l1 = l1->next) {
l2 = l1->next;
l1->next = l2->next;
if (l2->next != NULL) l2->next = l2->next->next;
}
return newHead;
}
//用map把新旧映射后，random对应下
public RandomListNode copyRandomList(RandomListNode head) {
if (head == null) return head;
RandomListNode newHead = new RandomListNode(head.label);
RandomListNode oldp = head.next;
RandomListNode newp = newHead;
Map<RandomListNode, RandomListNode> map = new HashMap<RandomListNode, RandomListNode>();
//采用map结构来存储对应的关系
map.put(newp, head);
while (oldp != null) {//复制旧的链表
RandomListNode newTemp = new RandomListNode(oldp.label);
map.put(newTemp, oldp);
newp.next = newTemp;
newp=newp.next;
oldp=oldp.next;
}
oldp=head;
newp=newHead;
while (newp!=null){//复制random指针
newp.random=map.get(newp).random;//取得旧节点的random指针
newp=newp.next;
oldp=oldp.next;
}
return head;
}
链表翻转
ListNode* reverseList(ListNode* head) {
ListNode* cur = NULL;
while (head) {
ListNode* next = head -> next;
head -> next = cur;
cur = head;
head = next;
}
return cur;
}
ListNode* reverseList(ListNode* head) {
if (!head || !(head -> next)) {
return head;
}
ListNode* node = reverseList(head -> next);
head -> next -> next = head;
head -> next = NULL;
return node;
}
链表去重。要用删除后面节点。head不须要处理
字符串
窗口 https://blog.csdn.net/whdAlive/article/details/81132383
回文的Manacher算法。
ide
KMP:优化
图
dijkstrasui
sptSet
邻接表 距离值 0和最大
a) 选择sptSet中不存在的顶点u并具备最小距离值。
b）包括u到sptSet。
c）更新u的全部相邻顶点的距离值。要更新距离值，请遍历全部相邻顶点。对于每一个相邻顶点v，若是u（来自源）和边缘uv的权重的距离值之和小于v的距离值，则更新v的距离值。
#include <stdio.h>
#include <limits.h>
// Number of vertices in the graph
#define V 9
int minDistance(int dist[], bool sptSet[])
{
// Initialize min value
int min = INT_MAX, min_index;
for (int v = 0; v < V; v++)
if (sptSet[v] == false && dist[v] <= min)
min = dist[v], min_index = v;
return min_index;
}
int printSolution(int dist[], int n)
{
printf("Vertex Distance from Source\n");
for (int i = 0; i < V; i++)
printf("%d tt %d\n", i, dist[i]);
}
void dijkstra(int graph[V][V], int src)
{
int dist[V];
bool sptSet[V];
for (int i = 0; i < V; i++)
dist[i] = INT_MAX, sptSet[i] = false;
dist[src] = 0;
// Find shortest path for all vertices
for (int count = 0; count < V-1; count++)
{
int u = minDistance(dist, sptSet);
sptSet[u] = true;
for (int v = 0; v < V; v++)
if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX
&& dist[u]+graph[u][v] < dist[v])
dist[v] = dist[u] + graph[u][v];
}
// print the constructed distance array
printSolution(dist, V);
} // driver program to test above function
int main()
{
/* Let us create the example graph discussed above */
int graph[V][V] = {{0, 4, 0, 0, 0, 0, 0, 8, 0},
{4, 0, 8, 0, 0, 0, 0, 11, 0},
{0, 8, 0, 7, 0, 4, 0, 0, 2},
{0, 0, 7, 0, 9, 14, 0, 0, 0},
{0, 0, 0, 9, 0, 10, 0, 0, 0},
{0, 0, 4, 14, 10, 0, 2, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 6},
{8, 11, 0, 0, 0, 0, 1, 0, 7},
{0, 0, 2, 0, 0, 0, 6, 7, 0}
};
dijkstra(graph, 0);
return 0;
}
Floyd
多源最短路径
最开始只容许通过 1 号顶点进行中转，接下来只容许通过 1 和 2 号顶点进行中转。
#include <bits/stdc++.h>
using namespace std;
#define V 4
#define INF 99999
void printSolution(int dist[][V]);
void floydWarshall (int graph[][V])
{
int dist[V][V], i, j, k;
for (i = 0; i < V; i++)
for (j = 0; j < V; j++)
dist[i][j] = graph[i][j];
for (k = 0; k < V; k++)
{
// Pick all vertices as source one by one
for (i = 0; i < V; i++)
{
// Pick all vertices as destination for the
// above picked source
for (j = 0; j < V; j++)
{
if (dist[i][k] + dist[k][j] < dist[i][j])
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
// Print the shortest distance matrix
printSolution(dist);
}
/* A utility function to print solution */
void printSolution(int dist[][V])
{
cout<<"The following matrix shows the shortest distances"
" between every pair of vertices \n";
for (int i = 0; i < V; i++)
{
for (int j = 0; j < V; j++)
{
if (dist[i][j] == INF)
cout<<"INF"<<" ";
else
cout<<dist[i][j]<<" ";
}
cout<<endl;
}
}
// Driver code
int main()
{
int graph[V][V] = { {0, 5, INF, 10},
{INF, 0, 3, INF},
{INF, INF, 0, 1},
{INF, INF, INF, 0}
};
// Print the solution
floydWarshall(graph);
return 0;
}
DFS
void Graph::addEdge(int v, int w)
{
adj[v].push_back(w); // Add w to v’s list.
}
void Graph::DFSUtil(int v, bool visited[])
{
// Mark the current node as visited and
// print it
visited[v] = true;
cout << v << " ";
// Recur for all the vertices adjacent
// to this vertex
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i)
if (!visited[*i])
DFSUtil(*i, visited);
}
// DFS traversal of the vertices reachable from v.
// It uses recursive DFSUtil()
void Graph::DFS(int v)
{
// Mark all the vertices as not visited
bool *visited = new bool[V];
for (int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function
// to print DFS traversal
DFSUtil(v, visited);
} void Graph::addEdge(int v, int w)
{
adj[v].push_back(w); // Add w to v’s list.
}
void Graph::DFSUtil(int v, bool visited[])
{
// Mark the current node as visited and
// print it
visited[v] = true;
cout << v << " ";
// Recur for all the vertices adjacent
// to this vertex
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i)
if (!visited[*i])
DFSUtil(*i, visited);
}
// DFS traversal of the vertices reachable from v.
// It uses recursive DFSUtil()
void Graph::DFS(int v)
{
// Mark all the vertices as not visited
bool *visited = new bool[V];
for (int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function
// to print DFS traversal
DFSUtil(v, visited);
}
应用
word search
class GFG {
// Let the given dictionary be following
static final String dictionary[] = { "GEEKS", "FOR", "QUIZ", "GUQ", "EE" };
static final int n = dictionary.length;
static final int M = 3, N = 3;
static boolean isWord(String str)
{
// Linearly search all words
for (int i = 0; i < n; i++)
if (str.equals(dictionary[i]))
return true;
return false;
}
// A recursive function to print all words present on boggle
static void findWordsUtil(char boggle[][], boolean visited[][], int i,
int j, String str)
{
visited[i][j] = true;
str = str + boggle[i][j];
// If str is present in dictionary, then print it
if (isWord(str))
System.out.println(str);
// Traverse 8 adjacent cells of boggle[i][j]
for (int row = i - 1; row <= i + 1 && row < M; row++)
for (int col = j - 1; col <= j + 1 && col < N; col++)
if (row >= 0 && col >= 0 && !visited[row][col])
findWordsUtil(boggle, visited, row, col, str);
str = "" + str.charAt(str.length() - 1);
visited[i][j] = false;
}
// Prints all words present in dictionary.
static void findWords(char boggle[][])
{
// Mark all characters as not visited
boolean visited[][] = new boolean[M][N];
// Initialize current string
String str = "";
// Consider every character and look for all words
// starting with this character
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++)
findWordsUtil(boggle, visited, i, j, str);
}
}
BFS
void Graph::BFS(int s)
{
bool *visited = new bool[V];
for(int i = 0; i < V; i++)
visited[i] = false;
list<int> queue;
visited[s] = true;
queue.push_back(s);
list<int>::iterator i;
while(!queue.empty())
{
s = queue.front();
cout << s << " ";
queue.pop_front();
for (i = adj[s].begin(); i != adj[s].end(); ++i)
{
if (!visited[*i])
{
visited[*i] = true;
queue.push_back(*i);
}
}
}
}
拓扑排序
修改 DFS以查找图的拓扑排序。在 DFS中，咱们从顶点开始，首先打印它，而后递归调用DFS做为其相邻顶点。在拓扑排序中，咱们使用临时堆栈。咱们不当即打印顶点，咱们首先递归调用其全部相邻顶点的拓扑排序，而后将其推送到堆栈。最后，打印堆栈的内容。请注意，只有当顶点的全部相邻顶点（及其相邻顶点等）已经在堆栈中时，顶点才会被推送到堆栈。
void Graph::topologicalSortUtil(int v, bool visited[],
stack<int> &Stack)
{
// Mark the current node as visited.
visited[v] = true;
// Recur for all the vertices adjacent to this vertex
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i)
if (!visited[*i])
topologicalSortUtil(*i, visited, Stack);
// Push current vertex to stack which stores result
Stack.push(v);
}
void Graph::topologicalSort()
{
stack<int> Stack;
// Mark all the vertices as not visited
bool *visited = new bool[V];
for (int i = 0; i < V; i++)
visited[i] = false;
// Call the recursive helper function to store Topological
// Sort starting from all vertices one by one
for (int i = 0; i < V; i++)
if (visited[i] == false)
topologicalSortUtil(i, visited, Stack);
// Print contents of stack
while (Stack.empty() == false)
{
cout << Stack.top() << " ";
Stack.pop();
}
}
最小生成树 primer:和最短路径差很少，每次找联通的定点 Kruskal：先找最小边各自链接 1.按重量的非递减顺序对全部边缘进行排序。 2.选择最小的边缘。检查它是否造成了到目前为止造成的生成树的循环。若是没有造成循环，则包括此边。不然，丢弃它。 3.重复步骤＃2，直到生成树中有（V-1）条边。
还路判断
DFS + 是否在前面路径上（visited+rectrace）
bool Graph::isCyclicUtil(int v, bool visited[], bool *recStack)
{
if(visited[v] == false)
{
// Mark the current node as visited and part of recursion stack
visited[v] = true;
recStack[v] = true;
// Recur for all the vertices adjacent to this vertex
list<int>::iterator i;
for(i = adj[v].begin(); i != adj[v].end(); ++i)
{
if ( !visited[*i] && isCyclicUtil(*i, visited, recStack) )
return true;
else if (recStack[*i])
return true;
}
}
recStack[v] = false; // remove the vertex from recursion stack
return false;
}
bool Graph::isCyclic()
{
// Mark all the vertices as not visited and not part of recursion
// stack
bool *visited = new bool[V];
bool *recStack = new bool[V];
for(int i = 0; i < V; i++)
{
visited[i] = false;
recStack[i] = false;
}
// Call the recursive helper function to detect cycle in different
// DFS trees
for(int i = 0; i < V; i++)
if (isCyclicUtil(i, visited, recStack))
return true;
return false;
}
另外一种：不相交集
int find(int parent[], int i)
{
if (parent[i] == -1)
return i;
return find(parent, parent[i]);
}
// A utility function to do union of two subsets
void Union(int parent[], int x, int y)
{
int xset = find(parent, x);
int yset = find(parent, y);
if(xset != yset)
{
parent[xset] = yset;
}
}
int isCycle( Graph* graph )
{
// Allocate memory for creating V subsets
int *parent = new int[graph->V * sizeof(int)];
// Initialize all subsets as single element sets
memset(parent, -1, sizeof(int) * graph->V);
// Iterate through all edges of graph, find subset of both
// vertices of every edge, if both subsets are same, then
// there is cycle in graph.
for(int i = 0; i < graph->E; ++i)
{
int x = find(parent, graph->edge[i].src);
int y = find(parent, graph->edge[i].dest);
if (x == y)
return 1;
Union(parent, x, y);
}
return 0;
}
割点和桥
割点：low[v] >= dnf[u]
桥：low[v] > dnf[u] 就说明V-U是桥
DP
01背包
ansx = max(ansx-1,ansx-1]+v[x]);
只须要一层.这里若是不逆序，每次算完的新的i的dp[j]会把以前的i-1的dp[j]覆盖。致使i重复计算，被用了屡次。好比背包V=8.2-3,1-2的物品
for(int i=1;i<=n;i++)
for(int j=v;j>=volume[i];j--)
dp[j]=max(dp[j],dp[j-volume[i]]+value[i]);
初始化：
装满的 ---只有0能装满0，其余的初始化为负无穷
不须要装满的-----全部的初始都为0
彻底背包：每件 物品 能够取无限件
for(int i=1;i<=n;i++)
for(int j=volume[i];j<=v;j++)
dp[j]=max(dp[j],dp[j-volume[i]]+value[i]);
多重背包：
max{dp[j-kvolume[i]]+kvalue[i]} 0<=k<=num[i]
可是可优化：二进制组合数，不用k个。若是不用二进制，咱们须要拆分红9个物品，利用二进制，咱们拆分红比9小的二进制数1 2 4 8，便可。
最小编辑距离，两个串通过多少改变同样。不同要么添加/删除/交换
if (word1[i - 1] == word2[j - 1]) edi = edi - 1;
else edi = min(min(edi + 1, edi - 1 + 1), edi - 1 + 1);
LIS(最长递增顺序)
普通DP：
for (int j = 0; j < i; ++j) {
if (nums[i] > nums[j]) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
咱们先创建一个数组ends，把首元素放进去，而后比较以后的元素，若是遍历到的新元素比ends数组中的首元素小的话，替换首元素为此新元素，若是遍历到的新元素比ends数组中的末尾元素还大的话，将此新元素添加到ends数组末尾(注意不覆盖原末尾元素)。若是遍历到的新元素比ends数组首元素大，比尾元素小时，此时用二分查找法找到第一个不小于此新元素的位置，覆盖掉位置的原来的数字，以此类推直至遍历完整个nums数组
int lengthOfLIS(vector<int>& nums) {
if (nums.empty()) return 0;
vector<int> ends{nums[0]};
for (auto a : nums) {
if (a < ends[0]) ends[0] = a;
else if (a > ends.back()) ends.push_back(a);
else {
int left = 0, right = ends.size();
while (left < right) {
int mid = left + (right - left) / 2;
if (ends[mid] < a) left = mid + 1;
else right = mid;
}
ends[right] = a;
}
}
return ends.size();
}
多模式匹配。相似KMP，把模式构形成带fail(kmp的next)基树。
A*启发式
计算过的加入close list待计算openlist 每次找最小的（起点代价+终点预估代价）