<memory.h>或<string.h>

void *memset(void *s, int ch, size_t n);

#include <algorithm>

sort(a,a+n)排序函式，從小到大，a為陣列名字，n為元素個數

sort(vector.begin(),vector.end())排序vector

只要資料型別定義了小於操作符，即可用sort

sort(a,a+n,compare)即可按照自定義順序排列，compare為比較函式，返回值為bool

lower_bound(a,a+n,x)二分查詢，查詢大於或等於x的第一個位置，只能查詢vector<>陣列，返回值為vector<>::iterator指標

    unique(vector1.begin(),vector1.end())，重排元素，使得所有值提前，返回值為重排後最後一個非重複值的後面的值的迭代器，即從返回值到vector1.end()是無意義的值，也是重複值的總數量

reverse(vector1.begin(),vector1.end())，反轉元素順序

next_permutation(p,p+n)，求下一個全排列，列舉用

#include <vector>   陣列

定義示例：vector<int> b(5);或者vector<int> a;

賦值：b[0]=1;只有第一種定義可以這樣賦值

函式：

int size()，獲取大小

void resize(int num)，改變大小

void push_back(int x)，向尾部新增元素

void pop_back()，刪除最後一個元素

void clear()，清空

bool empty()，檢查是否為空

iterator insert(iterator x,y)，向vector陣列的x位置插入元素y，x可以為v.begin()+2

iterator erase(iterator x)，刪除vector陣列的x位置元素

iterator begin()，返回頭指標

iterator end()，返回尾指標

vector<>::iterator為一個可以指向其元素的指標

#include <set>         集合，其中不含重複元素，且其中元素已從小到大排序，從1開始

定義示例：set<int> a;

函式：

int size()，獲取大小

iterator find(x)，若找到x，返回該鍵值迭代器的位置，否則，返回最後一個元素後面一個位置，即s.end()

void clear()，清空

bool empty()，檢查是否為空

iterator insert(y)，向set集合插入元素y

iterator erase(iterator x)，刪除set集合的值為x的元素，返回值為下一個位置的迭代器

iterator begin()，返回頭指標

iterator end()，返回尾指標

set<>::iterator為一個可以指向其元素的指標

#include <map>       對映，索引

         定義示例：map<string,int> month_name;

賦值：map[“July”]=7;

函式：

iterator find(y)，尋找索引值為y的元素，返回指向其的指標

iterator insert(map<string,int>(“July”,7))，向map對映插入元素(“July”,7)

iterator erase(iterator x)，刪除map對映的迭代器x的元素

map< string,int>::iterator l_it;;

   l_it=m.find(“July”);

   if(l_it==m.end())

        cout<<"we do not find July"<<endl;

   else  m.erase(l_it);  //delete July;

iterator begin()，返回頭指標

iterator end()，返回尾指標

map<>::iterator為一個可以指向其元素的指標

#include <stack>

定義示例：stack<int> s;

void push(x)，將值x壓入棧

void pop()，刪除頂部元素

top()，獲得棧頂元素，但不刪除

bool empty()，檢查是否為空

int size()，獲取大小

#include <queue>

定義示例：queue<int> q;

void push(x)，將值x入隊

void pop()，出隊

front()，獲得隊頭元素，但不刪除

bool empty()，檢查是否為空

int size()，獲取大小

#include <string>

string substr(int pos = 0,int n = npos) const;  //返回pos開始的n個字元組成的字串

void swap(string &s2);                                       //交換當前字串與s2的值

string &insert(int p0, const char *s);                //在p0位置插入字串

string &erase(int pos = 0, int n = npos);          //刪除pos開始的n個字元，返回修改後的字串

int find(char c, int pos = 0) const;                     //從pos開始查詢字元c在當前字串的位置

int find(const char *s,int pos = 0) const;         //從pos開始查詢字串s在當前串中的位置

演算法：

快速排序：

void quicksort(int *a,int l,int r){

         if(l>=r)

                  return;

         int temp=a[l];                                    //哨兵

         int i=l,j=r;

         while(i<j){

                  while(i<j){                                   //從右開始往左判斷

                          if(a[j]>=temp){

                                   j--;

                          }

                          else{

                                   a[i++]=a[j];

                                   break;

                          }

                  }

                  while(i<j){                                   //從左開始往右判斷

                          if(a[i]<=temp){

                                   i++;

                          }

                          else{

                                   a[j--]=a[i];

                                   break;

                          }

                  }

         }

         a[i]=temp;                                          //將哨兵放回中間位置

         quicksort(a,l,i-1);                               //左邊排序

         quicksort(a,i+1,r);                             //右邊排序

}

歸併排序：

void mergesort(int *a,int l,int r,int *b){

         if(l>=r)

                  return ;

         int mid=l+r;

         mid/=2;

         mergesort(a,l,mid,b);      //左邊有序

         mergesort(a,mid+1,r,b);  //右邊有序

         int k=l,i=l,j=mid+1;                    //注意k的初值

         while(i<=mid&&j<=r){              //將i-mid和j-r兩組有序序列，歸併在一個有序序列中

                  if(a[i]<=a[j])

                          b[k++]=a[i++];

                  else

                          b[k++]=a[j++];

         }

         while(i<=mid)                            //將i-mid剩餘的數放在最後

                  b[k++]=a[i++];

         while(j<=r)                                 //將j-r剩餘的數放在最後

                  b[k++]=a[j++];

         for(k=l;k<=r;k++)                       //將b陣列中的資料拷貝到原陣列中

                  a[k]=b[k];

}

並查集：

#define N 100

int father[N];

void init() {

    for(int i=0; i<N; i++)

      father[i] = i;

}

// 合併兩個元素所在的集合

void union(int x,int y) {

    x = getfather(x);

    y = getfather(y);

    if(x!= y)

       father[x]=y;

}

// 判斷兩個元素是否屬於同一個集合

bool same(int x,int y) {

    return getfather(x)==getfather(y);

}

// 獲取根結點

int getfather(int x) {

    while(x != father[x])

      x = father[x];

    return x;

}

// 獲取根結點，是上邊函式的改進，壓縮了路徑長度

int getfather(int x) {

    if(x != father[x])

      father[x] = getfather(father[x]); // 路徑壓縮修改的是father陣列

    return father[x];

}

二分查詢：

int erfen(int *a,int l,int r,int v){        //a為待查詢陣列，l為下界下標，r為上界下標，v為目標值

         int mid;

         while(l<=r){

                  mid=l+r;

                  mid/=2;

                  if(a[mid]==v)   return mid;

                  else if(a[mid]>v)      r=mid-1;

                  else  l=mid+1;

         }      

         return -1;

}

01揹包動態規劃：

int f[5000];

int v[201],w[201];

int main(int argc, char** argv) {

         int n=0,m,i,j,mx=0;

         cin>>n>>m;

         for(i=1;i<=n;i++){

                  cin>>w[i]>>v[i];

         }

         for(i=1;i<=n;i++){

                  for(j=m;j>=w[i];j--){

                          f[j]=max(f[j],f[j-w[i]]+v[i]);

                          mx=max(mx,f[j]);

                  }

         }

         cout<<mx;

         return 0;

}

LIS最長上升子序列

int LIS(int *a,int n){

         int *dp=new int[n];         //儲存以i為尾的最長上升子序列長度

         int mx=0,m,i,j;

         dp[0]=1;                            //初值，第一個字元為1

         for(i=1;i<n;i++){

                  m=0;

                  for(j=0;j<i;j++){        //對當前i之前的所有元素的最長上升子序列做判斷

                          if(dp[j]>m&&a[j]<a[i]){

                                   m=dp[j];

                          }

                  }

                  dp[i]=m+1;               //最大m值再加上1

                  mx=max(mx,dp[i]); //同時判斷所有最長上升子序列長度的最大值

         }

         return mx;

}

LCS最長公共子序列

動態規劃法：

void LCS(string str1,string str2)

{

         int x_len = str1.length();

         int y_len = str2.length();

         int arr[50][50] = {{0,0}};

         int i = 0;

         int j = 0;

         //動態規劃二維矩陣

         for(i = 1; i <= x_len; i++)

         {

                  for(j = 1; j <= y_len; j++)

                  {

                          if(str1[i - 1] == str2[j - 1])

                          {

                                   arr[i][j] = arr[i - 1][j - 1] + 1;

                         }

                          else

                          {

                                   if(arr[i][j - 1] >= arr[i - 1][j])

                                   {

                                            arr[i][j] = arr[i][j - 1];

                                   }

                                   else

                                  {

                                            arr[i][j] = arr[i -1][j];

                                   }

                          }

                  }

         }

         //列印最長公共子序列

         stack<char> s;

         for(i = x_len, j = y_len; i >= 1 && j >= 1;)

         {

                  if(str1[i - 1] == str2[j - 1])

                  {

                          s.push(str1[i - 1]);

                          //cout<<str1[i - 1]<<" ";

                          i--;

                          j--;

                  }

                  else

                  {

                          //  if(arr[i][j -1] >= arr[i - 1][j])//列印兩種情況

                          if(arr[i][j -1] > arr[i - 1][j])

                          {

                                   j--;

                          }

                          else

                          {

                                   i--;

                          }

                  }

         }

         while(!s.empty()){

                  cout<<s.top();

                  s.pop();

         }

         cout << endl;

}

遞迴法：（只能求數量）

int LCS(char* x,char *y){

         if(strlen(x)==0)                  return 0;

         if(strlen(y)==0)         return 0;

         if(*x==*y)         return LCS(x+1,y+1)+1;

         return max(LCS(x,y+1),LCS(x+1,y));

}

Dijkstra最短路徑演算法

#define MAX 9999999

#define NUM 6

int edge[NUM][NUM];                     //儲存兩點間距離

int dist[NUM];                                   //儲存到每個點的最短距離

int mark[NUM];                                 //標記是否已選

//n:多少個點  start:起始點   

void Dijkstra(int n,int start){

         int i,j,k=start;

         int min;

         for(i=0;i<n;i++){

                  mark[i]=0;

                  dist[i]=edge[start][i];

         }

         mark[start]=1;

         dist[start]=0;

         for(i=0;i<n;i++){

                  min=MAX;

                  for(j=0;j<n;j++){

                          if(!mark[j]&&dist[j]<min){

                                   min=dist[j];

                                   k=j;

                          }

                  }

                  mark[k]=1;

                  for(j=0;j<n;j++){

                          if(!mark[j]&&dist[j]>dist[k]+edge[k][j]){

                                   dist[j]=dist[k]+edge[k][j];

                          }

                  }

         }

}

Floyd

#define MAX 9999999

#define NUM 6

int edge[NUM][NUM];

int temp[NUM][NUM];

void Floyd(int a[NUM][NUM],int b[NUM][NUM]){

         int i,j,k;

         for(k=0;k<NUM;k++){

                  for(i=0;i<NUM;i++){

                          for(j=0;j<NUM;j++){

                                   if(k==0)

                                            b[i][j]=a[i][j];

相關推薦