算法题中的常用小程序记录（C++版）

1、得到一个数的逆序表示

如：1234 输出为 4321

int get_reverse(int num)
{
    int res = 0;
    while (num!=0)
    {
        res = res*10+num%10;
        num = num/10;
    }
    return res;   
}

2、判断一个数是否是回文

int huiwen(int n)
{
    int x=0;
    int s=n;
    while (s>0)
    {
        x = x*10+s%10;
        s = s/10;
    }
    if(x==n)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

3、判断一个数是否是素数

int sushu(int n)
{
    int x = n;
    int i;
    for(i=2;i<=n-1;i++)
    {
        if(x%i==0)
        {
            return 0;
        }
    }
    return 1;
}

4、删除一个数的第n位

int del(int num,int n)
{
    int p = 1;
    int ret = 0;
    int b = num/10;
    while (num!=0)
    {
        int a = num%10;
        num = num/10;
        if(p<n)
        {
            ret += a*pow(10,p-1);
        }
        else if(p>n)
        {
            ret += a*pow(10,p-2);
        }
        p++;
    }
    return ret;
}

5、得到一个数的位数

int get_nums(int n)
{
    int res = 0;
    while (n>0)
    {
        res++;
        n = n/10;
    }
    return res;
}

5、vector的find函数

vector<int>::iterator result = find( L.begin( ), L.end( ), 3 ); //L是个vector数组，查找3
if ( result == L.end( ) ) //没找到
    cout << "No" << endl;
else //找到
    cout << "Yes" << endl;

6、翻转多叉树

//网易游戏ME计划第一题：翻转多叉树
class Solution {
public:
    /**
     * 
     * @param node_data_list int整型二维数组 
     * @param node_data_listRowLen int node_data_list数组行数
     * @param node_data_listColLen int* node_data_list数组列数
     * @return int整型vector<vector<>>
     */
    void dfs(vector<vector<int>> &M,int row,vector<vector<int>> &result)
    {
        if(M[row].size()==0)
        {
            return;
        }
        
        while (M[row].size()!=0)
        {
            int temp = M[row].back();
            M[row].pop_back();
            result.push_back({temp,row});
            dfs(M,temp,result);
        }
    }
    vector<vector<int> > invert_tree(int** node_data_list, int node_data_listRowLen, int* node_data_listColLen) 
    {
        vector<vector<int>> result;
        vector<vector<int>> M(node_data_listRowLen+1);
        for(int i=0;i<node_data_listRowLen;i++)
        {
            M[node_data_list[i][1]].push_back(node_data_list[i][0]);
        }
        dfs(M,0,result);
        return result;
    }
};

7、n个数的全排列

    // 解法1：dfs（利用used标记）注：这个输出是字典序的！！！！！！！
    // int n;
    // vector<int> temp;
    // vector<vector<int>> res;
    // vector<bool> used;
    // void dfs(vector<int>& nums)
    // {
    //     if(temp.size()==n)
    //     {
    //         res.push_back(temp);
    //         return;
    //     }
    //     for(int i=0;i<n;i++)
    //     {
    //         if(!used[i])
    //         {
    //             used[i] = true;
    //             temp.push_back(nums[i]);
    //             dfs(nums);
    //             temp.pop_back();
    //             used[i] = false;
    //         }
    //     }
    // }
    // vector<vector<int>> permute(vector<int>& nums) 
    // {
    //     n = nums.size();
    //     used.resize(n,false);
    //     dfs(nums);
    //     return res;
    // }

8、n个数选m个数进行组合

vector<int> input;
int n,m;
vector<vector<int>> zuhe; //最终的组合结果
vector<int> temp;
void com(int index,int num,vector<int> vec)
{
    if(index==n+1)
    {
        return;
    }
    if(num==0)
    {
        //static int k =1;
        zuhe.push_back(vec);
        return;
    }
    vec.push_back(input[index]);
    com(index+1,num-1,vec);
    vec.pop_back();
    com(index+1,num,vec);
}
com(0,m,temp);

8.1、 1到n中k个数的组合种类

#include<bits/stdc++.h>
using namespace std;
class Solution {
public:
    void dfs(int n,int k,int start,vector<int>& temp,vector<vector<int>>& res)
    {
        if(temp.size()==k)
        {
            res.push_back(temp);
            return ;
        }
        //for(int i=start;i<=n - (k - temp.size()) + 1;i++)  //这里是回溯剪枝部分
        for(int i=start;i<=n;i++)
        {
            temp.push_back(i);
            dfs(n,k,i+1,temp,res);
            temp.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) 
    {
        vector<int> temp;
        vector<vector<int>> res;
        dfs(n,k,1,temp,res);
        return res;
    }
};

int main()
{
    int n = 5;
    int k = 3;
    Solution s;
    vector<vector<int>> res = s.combine(n,k);
    for(int i=0;i<res.size();i++)
    {
        for(int j=0;j<res[i].size();j++)
        {
            cout<<res[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
}

9、从某个城市到某个城市的路径（线状）

已知：题中给出哪些城市之间是相连的
解题思路：根据哪些城市之间是相连的，建立每个城市（节点）的邻接表，然后dfs判断起始点是否到了终点

vector<vector<int>> adjust_table;
vector<int> visited(n+1,0);
vector<vector<int>> res_path;
vector<int> path;
void dfs(vector<int> visited,vector<vector<int>>& res_path,vector<int>path,int start,int end)
{
    visited[start] = 1;
    path.push_back(start);
    if(start==end)
    {
        res_path.push_back(path);
    }
    else
    {
        for(int i=0;i<adjust_table[start].size();i++)
        {
            if(visited[adjust_table[start][i]]==0)
            {
                dfs(visited,res_path,path,adjust_table[start][i],end);
            }
        }
    }
    path.pop_back();
    visited[start] = 0;
}
dfs(visited,res_path,path,start,end);

9.1、从某个城市返回到某一个城市的路径（环状）

vector<vector<int>> linjie_biao;
vector<vector<int>> dist_biao;
vector<int> visited;
void dfs(vector<int> visited,vector<vector<int>>& res_path,vector<int>path,int start,int end,int flag)
{
    //visited[start] = 1;
    path.push_back(start);
    if(start==end&&flag==1)
    {
        res_path.push_back(path);
        return;
    }
    else
    {
        for(int i=0;i<linjie_biao[start].size();i++)
        {
            // if(visited[linjie_biao[start][i]]==0)
            // {
            //     flag = 1;
            //     dfs(visited,res_path,path,linjie_biao[start][i],end,flag);
            // }
            flag = 1;
            dfs(visited,res_path,path,linjie_biao[start][i],end,flag);
        }
    }
    path.pop_back();
    //visited[start] = 0;
}
    linjie_biao.resize(n+1);
    dist_biao.resize(n+1,vector<int>(n+1,0));
    visited.resize(n+1);
    for(int i=0;i<m;i++)
    {
        int start,end,dist;
        cin>>start>>end>>dist;
        linjie_biao[start].push_back(end);
        dist_biao[start][end] = dist;
    }
    //dfs(visited,res_path,path,start,end);
    vector<vector<int>> res_path;
    vector<int> path;
    dfs(visited,res_path,path,1,1,0);

10、使得数组两边方差和最小的分割点

#include<bits/stdc++.h>
using namespace std;

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param arr float浮点型一维数组 
     * @param arrLen int arr数组长度
     * @return int整型
     */
    //运用公式D(x) = E(x*x)-(E(X))^2
    //left[i]计算的是从左到右的方差
    //right[i]计算的是从右到左的方差
    int find_best_cut(float* arr, int arrLen) 
    {
        float *left  = new float[arrLen];
        float *right  = new float[arrLen];
        float left_sum = 0;
        float right_sum = 0;
        float left_square_sum = 0;
        float right_square_sum = 0;
        memset(left,0,arrLen);
        memset(right,0,arrLen);
        for(int i=0;i<arrLen;i++)
        {
            left_sum += arr[i];
            left_square_sum += arr[i]*arr[i];
            left[i] = left_square_sum/(i+1) - (left_sum/(i+1))*(left_sum/(i+1));
        }
        for(int i=arrLen-1;i>=0;i--)
        {
            right_sum += arr[i];
            right_square_sum += arr[i]*arr[i];
            right[i] = right_square_sum/(arrLen-i)-(right_sum/(arrLen-i))*(right_sum/(arrLen-i));
        }
        for(int i=0;i<arrLen;i++)
        {
            left[i] += right[i+1];
        }
        float minvar = left[0];
        int pos = 0;
        for(int i=0;i<arrLen;i++)
        {
            if(minvar>left[i])
            {
                minvar = left[i];
                pos = i;
            }
        }
        return (pos+1);
    }
};

11、判断一个数是否是2的整次幂

int main()          //判断一个数是不是2的整数次幂
{

    int n;
    while(cin>>n)
    {
        if((n&(n-1))==0)    //此处注意运算符的优先级，“==”比“&”优先级高
            cout<<"yes"<<endl;
        else
            cout<<"no"<<endl;
    }
    return 0;
}

12、数组中和为定值的组合种类

#include<bits/stdc++.h>
using namespace std;
void sumn(vector<int> &A,int start,int end,int sum,vector<int> &tmp,vector<vector<int>> &res)
{
    if (start == end && sum == 0)
    {
        res.push_back(tmp);
    }
    else if (start == end) return;
    else
    {
        if (sum >= A[start])
        {
            tmp.push_back(A[start]);
            sumn(A, start + 1, end, sum - A[start], tmp, res);
            tmp.pop_back();
        }
        sumn(A, start + 1, end, sum, tmp, res);
    }
}
int main()
{
    vector<int> input = {12,3,4,67,8};
    vector<vector<int>> res;
    vector<int> tmp;
    sumn(input,0,5,12,tmp,res);
    for(int i=0;i<res.size();i++)
    {
        for(int j=0;j<res[i].size();j++)
        {
            cout<<res[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
}