搜狐暢遊筆試題：1. 美麗的項鍊(動態規劃) 2.多線程併發交替輸出

時間 2019-11-06

原文原文鏈接

1. 美麗的項鍊(動態規劃)

1. 題目描述java

/**
連接：https://www.nowcoder.com/questionTerminal/e7e0230b12de4239a7f547a01d731522
來源：牛客網

編程題]美麗的項鍊
妞妞參加了Nowcoder Girl女生編程挑戰賽, 可是很遺憾, 她沒能獲得她最喜歡的黑天鵝水晶項鍊。
因而妞妞決定本身來製做一條美麗的項鍊。一條美麗的項鍊須要知足如下條件:
　　一、須要使用n種特定的水晶寶珠
　　二、第i種水晶寶珠的數量不能少於li顆, 也不能多於ri顆
　　三、一條美麗的項鍊由m顆寶珠組成
妞妞意識到知足條件的項鍊種數可能會不少, 因此但願你來幫助她計算一共有多少種製做美麗的項鍊的方案。


輸入描述:
　　輸入包括n+1行, 第一行包括兩個正整數(1 <= n <= 20, 1 <= m <= 100), 表示水晶寶珠的種數和一條美麗的項鍊須要的水晶寶珠的數量。
　　接下來的n行, 每行兩個整數li, ri(0 <= li <= ri <= 10), 表示第i種寶珠的數量限制區間。

輸出描述:
　　輸出一個整數, 表示知足限定條件的方案數。保證答案在64位整數範圍內。

示例1
輸入
　　3 5
　　0 3
　　0 3
　　0 3
輸出
　　12
*/

2. 代碼編程

二維數組dp[i][j]，表示用i+1種寶石選擇j個寶石的方案數組

設d[i][j]表示i+1種寶珠中取j個寶珠的方案數多線程

k表示寶珠個數上限-寶珠個數下限併發

則d[i][j]=d[i-1][j]+d[i-1][j-1].....+d[i-1][j-k]ide

例如：當2種寶珠選2個時的方案數spa

d[1][2]=d[0][2]+d[0][1]+d[0][0]（選擇從第2種寶珠中取i個時的方案數等於從第1種寶珠中分別取2個，取1個，取0個的和）

線程

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][]limit = new int[n][2];
        for(int i=0; i<n;i++){
            limit[i][0] = sc.nextInt();
            limit[i][1] = sc.nextInt();
        }
        long[][]dp = new long[n][m+1];
        for (int i = 0; i < m+1; i++) {
            if(i>=limit[0][0] && i<=limit[0][1]){
                dp[0][i]=1;
            }
        }
        for (int i = 0; i < n; i++) {
            if(limit[i][0] <=0){
                dp[i][0]=1;
            }
        }
        for (int i = 1; i <n; i++) {
            for (int j = 1; j < m+1; j++) {
                dp[i][j] = 0;
                for (int j2 = 0; j2 <= j; j2++) {
                    if(j2+limit[i][1]>=j && limit[i][0]+j2<=j){// li<=(j-j2)<=ri
                        dp[i][j] += dp[i-1][j2];
                    }
                }
            }
        }
        System.out.println(dp[n-1][m]);
    }
}

2.多線程併發交替輸出

1. 題目描述code

/**
建立兩個線程，其中一個輸出1-52，另一個輸出A-Z。輸出格式要求：12A 34B 56C 78D 依次類推
*/

2. 代碼blog

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition c1 = lock.newCondition();
        Condition c2 = lock.newCondition();
        new Thread(new Runnable(){
            @Override
            public void run() {
                try {
                    lock.lock();
                    for (int i = 1; i <= 52; i++) {
                        System.out.print(i);
                        if(i%2==0){
                            c1.signalAll();
                            c2.await();
                        }
                    }
                } catch (Exception e) {
                    // TODO: handle exception
                }finally{
                    lock.unlock();
                }
            }
            
        }).start();
        new Thread(new Runnable(){
            @Override
            public void run() {
                try {
                    lock.lock();
                    for (int i = 0; i < 26; i++) {
                        System.out.print((char)('A'+i)+" ");
                        c2.signalAll();
                        if(i!=25){
                            c1.await();
                        }
                    }
                } catch (Exception e) {
                    // TODO: handle exception
                }finally{
                    lock.unlock();
                }
            }
            
        }).start();
    }
}