每日一练 — 2021.12.20

---

一、最长公共前缀

1，程序简介

• 编写一个函数来查找字符串数组中的最长公共前缀。
• 如果不存在公共前缀，返回空字符串 “”。

示例 1：

• 输入：strs = [“flower”,“flow”,“flight”]
• 输出：“fl”

示例 2：

• 输入：strs = [“dog”,“racecar”,“car”]
• 输出：""
• 解释：输入不存在公共前缀。

提示：

0 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组成

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Mon Dec 20 09:16:34 2021
Function:
@author: 小梁aixj
"""
from typing import List
class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if len(strs) == 0:
            return ''
        i = 0
        lcp = []
        while True:
            done = False
            if i >= len(strs[0]):
                break
            j = 0
            while j < len(strs):
                if i < len(strs[j]):
                    if strs[j][i] != strs[0][i]:
                        done = True
                        break
                else:
                    done = True
                    break
                j += 1
            if not done:
                lcp.append(strs[0][i])
                i += 1
            else:
                break
        return ''.join(lcp)
# %%
s = Solution()
print(s.longestCommonPrefix(strs = ['flower', 'flow', 'flight']))  #fl
print(s.longestCommonPrefix(strs = ['dog', 'racecar', 'car'])) #''

3，运行结果

二、最小路径和

1，程序简介

• 给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

• 说明：每次只能向下或者向右移动一步。

示例 1：

• 输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
• 输出：7
• 解释：因为路径 1→3→1→1→1 的总和最小。

示例 2：

• 输入：grid = [[1,2,3],[4,5,6]]
• 输出：12

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 200
0 <= grid[i][j] <= 100

以下程序实现了这一功能，请你填补空白处内容：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static inline int min(int a, int b)
{
	return a < b ? a : b;
}
int minPathSum(int **grid, int gridRowSize, int gridColSize)
{
	int i, j;
	int **dp = malloc(gridRowSize * sizeof(int *));
	for (i = 0; i < gridRowSize; i++)
	{
		dp[i] = malloc(gridColSize * sizeof(int));
	}
	dp[0][0] = grid[0][0];
	int sum = dp[0][0];
	for (i = 1; i < gridRowSize; i++)
	{
		sum += grid[i][0];
		dp[i][0] = sum;
	}
	sum = dp[0][0];
	for (i = 1; i < gridColSize; i++)
	{
		sum += grid[0][i];
		dp[0][i] = sum;
	}
	for (i = 1; i < gridRowSize; i++)
	{
		for (j = 1; j < gridColSize; j++)
		{
			_____________________
		}
	}
	return dp[gridRowSize - 1][gridColSize - 1];
}
int main(int argc, char **argv)
{
	int i, j;
	int row = argc - 1;
	int col = strlen(argv[1]);
	int **grid = malloc(row * sizeof(int *));
	for (i = 0; i < row; i++)
	{
		grid[i] = malloc(col * sizeof(int));
		for (j = 0; j < col; j++)
		{
			grid[i][j] = argv[i + 1][j] - '0';
			printf("%d ", grid[i][j]);
		}
		printf("\n");
	}
	printf("%d\n", minPathSum(grid, row, col));
	return 0;
}

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Mon Dec 20 09:17:26 2021
Function:
@author: 小梁aixj
"""
class Solution(object):
    def minPathSum(self, grid):
        height = len(grid)
        if height == 0:
            return 0
        width = len(grid[0])
        pathmap = []
        for i in range(height):
            pathmap.append([100000000000] * width)
        pathmap[0][0] = grid[0][0]
        for i in range(height):
            for j in range(width):
                compare = [pathmap[i][j]]
                if i-1 >= 0:
                    compare.append(pathmap[i - 1][j] + grid[i][j])
                if j-1 >= 0:
                    compare.append(pathmap[i][j - 1] + grid[i][j])
                pathmap[i][j] = min(compare)
        return pathmap[-1][-1]
#%%
s = Solution()
print(s.minPathSum(grid = [[1, 3, 1],[1, 5, 1],[4, 2, 1]]))
print(s.minPathSum(grid = [[1, 2, 3],[4, 5, 6]]))

3，运行结果

三、删除排序链表中的重复元素 ||

1，程序简介

• 存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中 没有重复出现 的数字。
• 返回同样按升序排列的结果链表。

示例 1：

• 输入：head = [1,2,3,3,4,4,5]
• 输出：[1,2,5]

示例 2：

• 输入：head = [1,1,1,2,3]
  -输出：[2,3]

提示：

链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序排列

以下程序实现了这一功能，请你填补空白处内容：

#include <stdio.h>
#include <stdlib.h>
struct ListNode
{
	int val;
	struct ListNode *next;
};
struct ListNode *deleteDuplicates(struct ListNode *head)
{
	struct ListNode dummy;
	struct ListNode *p, *q, *prev;
	prev = &dummy;
	dummy.next = head;
	p = q = head;
	while (p != NULL)
	{
		_____________________
	}
	return dummy.next;
}
int main(int argc, char **argv)
{
	int i;
	struct ListNode *head = NULL;
	struct ListNode *prev = NULL;
	struct ListNode *p;
	for (i = 0; i < argc - 1; i++)
	{
		p = malloc(sizeof(*p));
		p->val = atoi(argv[i + 1]);
		p->next = NULL;
		if (head == NULL)
		{
			head = p;
			prev = head;
		}
		else
		{
			prev->next = p;
			prev = p;
		}
	}
	p = deleteDuplicates(head);
	while (p != NULL)
	{
		printf("%d ", p->val);
		p = p->next;
	}
	printf("\n");
	return 0;
}

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Mon Dec 20 09:17:39 2021
Function:
@author: 小梁aixj
"""
class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None
class LinkList:
    def __init__(self):
        self.head = None
    def initList(self, data):
        self.head = ListNode(data[0])
        r = self.head
        p = self.head
        for i in data[1:]:
            node = ListNode(i)
            p.next = node 
            p = p.next
        return r
    def convert_list(self, head):
        ret = []
        if head == None:
            return
        node = head
        while node != None:
            ret.append(node.val)
            node = node.next
        return ret
class Solution(object):
    def deleteDuplicates(self, head):
        newnodehead = None
        newnode = None
        node = head
        while node:
            lastval = node.val
            if node.next and node.next.val == lastval:
                while node and node.val == lastval:
                    node = node.next
                continue
            if not newnodehead:
                newnode = ListNode(node.val)
                newnodehead = newnode
            else:
                newnode.next = ListNode(node.val)
                newnode = newnode.next
            node = node.next
        return newnodehead
# %%
l = LinkList()
list1 = [1,2,3,3,4,4,5]
l1 = l.initList(list1)
s = Solution()
print(l.convert_list(s.deleteDuplicates(l1))) 
                

3，运行结果