搜狐畅游笔试题：1. 美丽的项链(动态规划) 2.多线程并发交替输出

1. 美丽的项链(动态规划)

1. 题目描述

/**
链接：https://www.nowcoder.com/questionTerminal/e7e0230b12de4239a7f547a01d731522
来源：牛客网

编程题]美丽的项链
妞妞参加了Nowcoder Girl女生编程挑战赛, 但是很遗憾, 她没能得到她最喜欢的黑天鹅水晶项链。
于是妞妞决定自己来制作一条美丽的项链。一条美丽的项链需要满足以下条件:
　　1、需要使用n种特定的水晶宝珠
　　2、第i种水晶宝珠的数量不能少于li颗, 也不能多于ri颗
　　3、一条美丽的项链由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]

例如：当2种宝珠选2个时的方案数

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. 题目描述

/**
创建两个线程，其中一个输出1-52，另外一个输出A-Z。输出格式要求：12A 34B 56C 78D 依次类推
*/

2. 代码

 

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();
    }
}