【职业规划】Inceptio.ai提前批笔试算法岗提前批笔试复盘总结

一共2道算法题
第一道：
邮局最短距离题目：
【题目】

一条直线上有居民点，邮局只能建在居民点上。给定一个有序整型数组arr，每个值表示居民点的一维坐标，再给定一个正数num，表示邮局数量。选择num个居民点建立num个邮局，使得所有的居民点到邮局的总距离最短，返回最短的总距离。

【基本思路】

方法一。动态规划。首先解决一个问题，如果在arr[0…j]上只能建立一个邮局，最短总距离是多少？如果居民点有奇数个，邮局建在最中间的那个居民点可以使总距离最短，如果居民点有偶数个，中点有两个，邮局建在哪个都可以让总距离最短。可以根据这个思路计算上面的问题。‘

生成规模为N×M的矩阵w，w[i][j]表示如果在arr[i…j]上只能建立一个邮局，最短的总距离。w[i][j]的值可以通过如下计算得到：
　
　　w[i][j] = w[i][j-1] + arr[j] - arr[(i + j) / 2]

有了w矩阵后，接下来进行动态规划过程。假设dp[i][j]表示如果在arr[0…j]上建立i+1个邮局的最短总距离。所以dp[0][j]的值表示如果在arr[0…j]上建立一个邮局最短的总距离。很明显，就是w[0][j]。那么dp[0][0…N-1]上的所有值都可以直接用w[0][0…N-1]赋值。

当可以建立不止一个邮局时，情况如下：
　　
　　1、前i-1个邮局负责arr[0]，第i个邮局负责arr[1…j]，总距离为dp[i-1][0] + w[1][j]
　　2、前i-1个邮局负责arr[0…1]，第i个邮局负责arr[2…j]，总距离为dp[i-1][1] + w[2][j]
　　3、前i-1个邮局负责arr[0…k]，第i个邮局负责arr[k+1…j]，总距离为dp[i-1][k] + w[k+1][j]

实际上k的取值到j-1就可以了，因为在还有最后一个居民的时候仍然可以建立一个邮局，那么在该居民点建立一个邮局一定没坏处，这样就可以不用考虑：前i-1个邮局负责arr[0…j]，第i个邮局负责arr[j+1…j]的情况，避免w矩阵溢出。

#python3.5
def siteSelectionQuestion1(arr, num):
    if arr == None or len(arr) == 0 or num < 1 or len(arr) < num:
        return 0
    w = [[0 for i in range(len(arr))] for j in range(len(arr))]
    for i in range(len(arr)):
        for j in range(i+1, len(arr)):
            w[i][j] = w[i][j-1] + arr[j] - arr[(i+j) // 2]
    dp = [w[0][i] for i in range(len(arr))]
    for i in range(1, num):
        for j in range(len(arr)-1, i-1, -1):
            minDistance = sys.maxsize
            for k in range(i-1, j):
                minDistance = min(minDistance, max(dp[k], w[k+1][j]))
            dp[j] = minDistance
    return dp[-1]

int main()
{
		int a[309];
		int dp[309][309]; //dp[i][j] 代表从起点到i点之间 建立 j 个邮局的情况；
		int w[309][309]; // w[l][r] 为 在点L与点R之间建立一个邮局的最短距离之和 ； w[l][r] = w[l][r-1] + a[r] - a[(r+l)>>1];
		int n, m;
        cin>>n>>m;
        for(int i = 1; i <= n; i++) cin>>a[i];  //输入村庄的位置
        memset(w, 0, sizeof(w));  // 把所有的距离置0
        for(int i = 1; i <= n; i++){
            for(int j = i + 1; j <= n; j++){
                w[i][j] = w[i][j - 1] + a[j] - a[(i + j) >> 1]; //计算在L到R之间有一个邮局时， 所有村庄的距离最短之和
            }
        }
        for(int i = 1; i <= n; i++){
            dp[i][1] = w[1][i];  //在1-i之间建立一个邮局时 最短距离
            dp[i][i] = 0;
        }
        for(int i = 1; i <= n; i++){ // 最后一个村庄的位置
            for(int j = 2; j <= min(m, i); j++){ //min(m, j) 保证了 邮局的个数比村庄的个数少
                dp[i][j] = INF;
                for(int k = j; k <= i - 1; k++){ //k是为了一个一个的扩展。 意思是： 从 1 到 k 建立了 j - 1 个邮局 加
                                   //上 从 k-1 到 i 建立一个邮局时 在k-1到i区间上的所有村庄到该邮局的距离之和的最小值
                    dp[i][j] = min(dp[i][j], dp[k][j - 1] + w[k + 1][i]);
                    //dp[i][j] = dp[k][j - 1] + w[k + 1][i]
                    //k起始位置应该大于邮局的数量，然后来挨个遍历递推，找最优的。
                }
 
            }
        }
        cout<<dp[n][m];
}

第二道：
链表翻转：

ListNode* reverse(ListNode* head){
    ListNode* ans{};
    while (head){
        ListNode* tmp = head->next;
        head->next = ans;
        ans = head;
        head = tmp;
    }
    return ans;
}

    ListNode* reverse(ListNode* head,ListNode* tail){
        auto p1 = head, p2 = head->next;
        while (p2 != tail) {
            auto p3 = p2->next;
            p2->next = p1;
            p1 = p2, p2 = p3;
        }
        return p1;
    }

        ListNode* p1 = head;
        ListNode* p2 = head->next;
        p1->next = nullptr;
        while (p2!=nullptr){
            ListNode* p3 = p2->next;
            p2->next = p1;
            p1 = p2; p2 = p3;
        }
        return p1;