2021-5-24数字反转/最小编辑代价/岛屿数量/两个链表地一个公共节点

主题：
日常学习记录,包括：

• 算法题：数字反转
• 算法题：最小编辑代价
• 算法题：岛屿数量
• 算法题：两个链表的第一个公共节点

内容：

1 数字反转
题目描述
将给出的32位整数x翻转。
例1:x=123，返回321
例2:x=-123，返回-321
你有注意到翻转后的整数可能溢出吗？因为给出的是32位整数，则其数值范围为[−2^{31}, 2^{31} − 1]
翻转可能会导致溢出，如果反转后的结果会溢出就返回 0。

思路：
首先，这个不必进行一个数据结构来存储每一位数字，直接计算就行
采用的是，取出每一个数字，然后对之前结果进行左移（×10），然后将这
个数字作为个位数字加上去。这样就会得到相反的结果

通过采用是不是可以返回原来的值(newRes-t)/10，来判定是否出现了溢出的现象。这个很巧妙

代码：

int reverse(int x) {
        // write code here
        //怎么判断溢出？用简单的方法
        
        //首先，这个不必进行一个数据结构来存储每一位数字，直接计算就行
        //采用的是，取出每一个数字，然后对之前结果进行左移（×10），然后将这个数字作为个位数字加上去。这样就会得到相反的结果
        
        //通过采用是不是可以返回原来的值(newRes-t)/10，来判定是否出现了溢出的现象。这个很巧妙
        int res = 0;
        while( x!=0 )
        {
            int t = x%10;
            x = x/10;
            int newRes = 10*res+t; //这个公式很重要
            if((newRes-t)/10 !=res)
            {
                return 0;
            }
            res = newRes;
        }
        return res;
    }

2 最小编辑代价
题目描述
给定两个字符串str1和str2，再给定三个整数ic，dc和rc，分别代表插入、删除和替换一个
字符的代价，请输出将str1编辑成str2的最小代价。

思路：
1.动态规划：dp[i][j]表示word1的前i个字符编辑成word2的前j个字符需要的最小操作数
注意是”谁编辑成谁“这个问题。
2.初始状态：dp[i][0] = i，i次删除；dp[0][i] = i，i次插入
3.过渡公式：
当i字符等于j字符时：dp[i][j] = dp[i-1][j-1]，不需要额外操作
当i字符不等于j字符时：dp[i][j] = Math.min(insert, delete, replace)
int insert = dp[i][j-1] + 1; i个编辑成j-1个字符，再插入一个j
int delete = dp[i-1][j] + 1; i-1个编辑成j个字母，再删除一个i
int replace = dp[i-1][j-1] + 1; i-1个编辑成j-1个字母，再将i替换成j
注意：动态规划的题，最终要的就是状态转移方程。也就是如何把问题转化为子问题。
问题，使用”状态“来进行表示。

代码：

int minEditCost(string str1, string str2, int ic, int dc, int rc) {
        // write code here
        int len1 = str1.size();
        cout<<str1<<endl;
        int len2 = str2.size();
        int dp[len1+1][len2+1];
        memset(dp,0,sizeof(dp));
        //进行初始化
        for(int i=0;i<=len1;i++)
        {
            dp[i][0] = i*dc;  //这里要注意，要乘以dc，不要只写一个i
        }
        for(int i = 0;i<=len2;i++)
        {
            dp[0][i] = i*ic;   //这里要注意，要乘以ic
        }
        for(int i=1;i<=len1;i++)
        {
            for(int j=1;j<=len2;j++)
            {
                if(str1[i-1] == str2[j-1])
                {
                    dp[i][j] = dp[i-1][j-1];
                }
                else{
                    int insert = dp[i][j-1]+ic;
                    int del = dp[i-1][j]+dc;
                    int replace = dp[i-1][j-1]+rc;
                    dp[i][j] = min(min(insert, del),replace);
                }
            }
        }
        return dp[len1][len2];
    }

3 岛屿数量

问题描述：
给一个01矩阵，1代表是陆地，0代表海洋， 如果两个1相邻，那么这两个1属于同一个岛。
我们只考虑上下左右为相邻。岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。
思路：
从左到右，从上到下进行遍历。对于为1的元素，就进行探索。探索是递归的探索，是将这个元素
相关的，可以构成一个岛屿的元素全部找出来，并且，变成0.这样，才不会干扰下次进行探索。
这个是最基本的思路。实现探索有不同的方式。

代码：

int solve(vector<vector<char> >& grid) {
        // write code here
        
        int nr = grid.size();
        int nc = grid[0].size();
        int num = 0;
        for(int i=0;i<nr;i++)
        {
            for(int j=0;j<nc;j++)
            {
                if(grid[i][j] == '1')
                {
                    num++;
                    visit2(grid, i, j);
                }
            }
        }
        
        return num;
    }
//使用这种方法来进行遍历，也可以通过队列来进行遍历
    void visit(vector<vector<char>>& grid, int i,int j)
    {
        //如果跑出去的话，或者遍历到0,就返回
        if(i<0 || i>=grid.size() || j<0 || j>=grid[0].size() || grid[i][j]=='0')
        {
            return ;
        }
        
        //进行正常的遍历
        grid[i][j] = '0';
        visit(grid, i-1, j);
        visit(grid, i+1, j);
        visit(grid, i, j-1);
        visit(grid, i, j+1);
    }
    
    //使用队列方法进行遍历，实际上是树的bfs
    void visit2(vector<vector<char>>& grid, int i,int j)
    {
        int row = grid.size();
        int col = grid[0].size();
        queue<int> q;
        q.push(i*row+j); //这个实际上是进行压缩，将这个位置的两个坐标压缩为1个。还可以进行精准还原
        while(!q.empty())
        {
            int d = q.front();
            q.pop();
            int jj = d%row; //解压缩
            int ii = d/row;
            if(ii-1>=0 && grid[ii-1][jj]=='1') //下
            {
                q.push(row*(ii-1)+jj);
                grid[ii-1][jj] = '0';
            }
            if(ii+1<row && grid[ii+1][jj]=='1') //上
            {
                q.push(row*(ii+1)+jj);
                grid[ii+1][jj] = '0';
            }
            if(jj-1>=0 && grid[ii][jj-1]=='1')
            {
                q.push(row*(ii)+jj-1);
                grid[ii][jj-1] = '0';
            }
            if(jj<col && grid[ii][jj+1]=='1')
            {
                q.push(row*(ii)+jj+1);
                grid[ii][jj+1] = '0';
            }
        }
    }

4 两个链表的第一个公共结点
题目描述：
输入两个无环的单链表，找出它们的第一个公共结点。（注意因为传入数据是链表，
所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）
思路：我们希望是两个链表的长度相同。这样的话，就可以实现，一个指针指向链表1,另外一个指向
链表2.相等的返回。不相等的话，就都前进一格。
为了让两个链表相同，我们可以让 “在逻辑上加上对方”。这样两个链表都变成了len1+len2
实现方法就是，当为空的时候，赋给对方头节点的值

代码：

ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        ListNode* a = pHead1;
        ListNode* b = pHead2;
        while(a!=b)
        {
            a = a?a->next:pHead2;
            b = b?b->next:pHead1;
        }
        return a;
    }

---------------------------end-------------------------------
有用的话，不妨点个赞吧