基础算法1

分治

归并排序

void Merges(int a[], int start, int mid, int end, int temp[])
{
	int first = start, mids = mid + 1, last = end, k = 0;
	while (first <= mid && mids <= last)
	{
		if (a[first] < a[mids])
			temp[k++] = a[first++];
		else
			temp[k++] = a[mids++];
	}
	while (first <= mid)
		temp[k++] = a[first++];
	while (mids <= last)
		temp[k++] = a[mids++];
	for (int i = 0; i < k; i++)//在以上代码运行完毕后，k就为当前数组元素个数，这时需要将辅助数组temp里面的内容复制到原数组中去，k不能取等号
		a[start + i] = temp[i];
}

//归并排序辅助函数2  (递归)
void Merge(int a[], int start, int end, int temp[])
{
	if (start >= end)
		return;
	int mid = start + (end - start) / 2;  //取中，防止溢出
	Merge(a, start, mid, temp);         //左右分治
	Merge(a, mid + 1, end, temp);    //左右分治
	Merges(a, start, mid, end, temp);   //最终排序
}

//归并排序
void Merge_sort(int a[], int length)
{
	int* temp = (int*)malloc(sizeof(int) * length);
	Merge(a, 0, length - 1, temp);
	//Merge(a, length, temp);
	free(temp);
}

快速排序

int Part_Sort_0(int a[], int first, int last)
{
	int start = first, end = last;
	while (start < end)
	{
		while (start < end && a[start] <= a[end])
			end--;
		if (start < end)
		{
			Swap(&a[start], &a[end]);
			start++;
		}                           //加等号
		while (start < end && a[start] <= a[end])
			start++;
		if (start < end)
		{
			Swap(&a[start], &a[end]);
			end--;
		}
	}
	return start;
}


void QuickSort(int a[], int first, int end)
{
	if (first >= end)
		return;
	int mid = Part_Sort_0(a, first, end);
	QuickSort(a, first, mid - 1);
	QuickSort(a, mid + 1, end);
}

动态规划

最大子段和

int MaxSum(int n,int *a)
{
	int max_sum=0;sum=0;
    for(int i=0;i<=n;i++)
    {
		if(sum>0) 
			sum+= a[i];
        else 
        	sum=a[i];
        max_sum=max(max_sum,b);
    }
    return max_sum;
}

最长公共子序列

int longestCommonSubsequence(string text1, string text2) {
        int m1=text1.size(),m2=text2.size();

        vector<vector<int>> dp = vector<vector<int>>(m1+1,vector<int>(m2+1));

        text1=' '+text1;
        text2=' '+text2;

        for(int i=1;i<=m1;i++)
        {
            for(int j=1;j<=m2;j++)
            {
                if(text1[i]==text2[j])
                dp[i][j]=dp[i-1][j-1]+1;
                else
                dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[m1][m2];
    }
};

01背包

#include<iostream>
#include<vector>

using namespace std;
int N,M;
int v[1010],w[1010];


// 在只看前 i 个物品的情况下
// 选择第 i 个物品的最大价值 dp[i][j] = d[i-1][j-v[i]];
// 不选择第 i 个物品的最大价值 dp[i][j] = d[i-1][j];

int dp[1010][1010];
int main()
{
    cin>>N>>M;
    for(int i=1;i<=N;i++)
    {
        cin>>v[i]>>w[i];
    }
    
    for(int i=1;i<=N;i++)
    for(int j=0;j<=M;j++)
    {
        dp[i][j]=dp[i-1][j];
        if(j>=v[i])
        {
            dp[i][j]=max(dp[i-1][j-v[i]]+w[i],dp[i-1][j]);
        }
       
    }
    cout<<dp[N][M];
}

贪心

活动选择

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
struct cmp{
	bool operator()(vector<int>&a1, vector<int>&a2){
		return a1[1] < a2[1];
	}
};
int getNum(vector<vector<int>>events){
	sort(events.begin(), events.end(), cmp());
	int i = 0;
	int num = 1;
	for (int j = 1; j < events.size(); j++){
		if (events[j][0] >= events[i][1]){
			num++;
			i = j;
		}
	}
	return num;
}

单元最短路径

#include<iostream>
#include<bits/stdc++.h>
using namespace std;
 
 int N,M;
 vector<vector<int>> edge,nums;
 vector<bool>Hash;
 vector<long long> dist;
 
 typedef pair<long long,int> PAI;
 
 int Dijkstra()
 {
     dist[1]=0;
     priority_queue<PAI,vector<PAI>,greater<PAI>> q;
     q.push({0,1});
     
     while(q.size())
     {
         auto e = q.top();
         q.pop();
         
         int v = e.second ;
         long long sum = e.first;
         
         if(Hash[v]) continue;
         Hash[v]=1;
         
         for(int i = 0;i<edge[v].size();i++)
         {
             int vv = edge[v][i],dis = nums[v][i];
             if(dist[vv]>sum+dis)
             {
                 dist[vv] = sum+dis;
                 q.push({dist[vv],vv});
             }
           
         }
     }
     if(dist[N]==INT_MAX)return -1;
     return dist[N];
 }
 
 int main()
 {
     cin>>N>>M;
     edge = vector<vector<int>>(N+1);
     nums = vector<vector<int>>(N+1);
     Hash = vector<bool>(N+1);
     dist = vector<long long>(N+1,INT_MAX);
     for(int i = 0;i<M;i++)
     {
         int a,b,c;
         cin>>a>>b>>c;
         edge[a].push_back(b);
         nums[a].push_back(c);
     }
     
     cout<<Dijkstra();
 }