텐 센트 2018 춘수 필기시험 (기계 배치, 화가 소 Q, 소 Q 의 노래 리스트, 식 탐 이 많은 소 Q)

1. 식 탐 이 많은 작은 Q
큐 군의 부 모 는 N 일간 출장 을 가 야 하 는데 가기 전에 큐 에 게 초콜릿 M 조각 을 남 겼 다.Q. 매일 먹 는 초콜릿 의 수량 이 전날 의 절반 보다 적지 않 기로 결 정 했 습 니 다. 하지만 그 는 부모님 이 돌아 오시 기 전 어느 날 초콜릿 을 먹 지 않 고 싶 지 않 았 습 니 다. 첫날 초콜릿 을 얼마나 많이 먹 을 수 있 는 지 물 어보 세 요.
입력 설명:
입력 마다 테스트 용례 가 포함 되 어 있 습 니 다.각 테스트 용례 의 첫 줄 에는 부모 의 출장 일수 N (N < = 50000) 과 초콜릿 의 수량 M (N < = M < = 100000) 을 나타 내 는 두 개의 정수 가 포함 되 어 있다.
출력 설명:
출력 한 개 수 는 작은 Q 가 첫날 초콜릿 을 얼마나 먹 을 수 있 는 지 를 나타 낸다.
입력 예 1:
3 7
출력 예 1:
4
//      
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        getMax2( n, m);
    }

    static void getMax(int n,int m){
        //        1    ,   1    M-(N-1)    
        int low=1,high=m-n+1;//       low-high  ,        ,      O(logn)
        while(low<=high){
            ////         ;      2
            int mid=(low+high+1)>>1;
            if(sum(mid,n)==m){
                System.out.println(mid);//      mid    ,          ,      
                return;
            }else if(sum(mid,n)>m){
                high=mid-1;
            }else{
                low=mid+1;
            }
        }
        //        
        System.out.println(high);
    }

    static int sum(int eat,int day){
        int sum=eat;
        for(int i=1;i>1;//    
            sum+=eat;
        }
        return sum;
    }

2. 수열 뒤 집기
작은 Q 는 반전 수열 이 라 고 정의 합 니 다. 주어진 정수 n 과 m 는 n 이 2m 로 정 리 될 수 있 도록 합 니 다.한 줄 의 연속 증가 정수 수열 1, 2, 3, 4..........................................................................예 를 들 어 n = 8, m = 2, 수열 은: - 1, - 2, + 3, + 4, - 5, - 6, + 7, + 8 이다. 그리고 n = 4, m = 1, 수열 은: - 1, + 2, - 3, + 4 이다.
입력 설명:
입력 은 두 개의 정수 n 과 m (2 < = n < = 10 ^ 9, 1 < = m) 를 포함 하고 n 이 2m 로 정 제 될 수 있 도록 만족 합 니 다.
출력 설명:
이전 n 항목 과 정 수 를 출력 합 니 다.
입력 예 1:
8 2
출력 예 1:
8
사고: 문제 풀이 사고: 하나의 수열 은 모두 n / 2m 그룹 이 있 고 각 그룹의 합 은 m ^ 2 이기 때문에 앞의 n 항목 과 는: (n / 2m) (m ^ 2) = mn / 2 이다.
int 를 사용 하지 않도록 주의 하 세 요. log 형식 을 사용 해 야 합 니 다.
public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        long n=sc.nextInt();
        long m=sc.nextInt();
        long result=n*m/2;
        System.out.println(result);
    }

3 작은 Q 의 트랙 리스트
작은 Q 는 X 곡 길이 가 A 인 다른 노래 와 Y 곡 길이 가 B 인 다른 노래 가 있 습 니 다. 현재 작은 Q 는 이 노래 들 로 총 길이 가 K 인 트랙 리스트 를 만 들 고 싶 습 니 다. 각 곡 은 트랙 리스트 에 한 번 만 나 올 수 있 습 니 다. 트랙 리스트 에 있 는 노래의 선후 순 서 를 고려 하지 않 고 몇 가지 트랙 리스트 를 구성 하 는 방법 이 있 습 니까?
입력 설명:
입력 마다 테스트 용례 가 포함 되 어 있 습 니 다.각 테스트 용례 의 첫 줄 은 하나의 정 수 를 포함 하고 트랙 리스트 의 총 길이 K (1 < = K < = 1000) 를 나타 낸다.다음 줄 에는 노래의 첫 번 째 길이 A (A < = 10) 와 수량 X (X < = 100), 그리고 노래의 두 번 째 길이 B (B < = 10) 와 수량 Y (Y < = 100) 를 나타 내 는 네 개의 정수 가 포함 되 어 있다.보증 A 는 B 와 같 지 않다.
출력 설명:
하나의 정 수 를 출력 하여 트랙 리스트 를 구성 하 는 방법 을 나타 낸다.답 이 클 수 있 기 때문에 1000000007 모델 을 출력 한 결과 입 니 다.
입력 예 1:
5 2 3 3 3
출력 예 1:
9
생각:
먼저 i 개 수 에서 j 개 수 를 선택 한 조합 수 를 구하 십시오. 주의 하 세 요. j 개 를 추출 한 배열 조합 은 1: c [i] [0] = 1 입 니 다.
그리고 a 의 개 수 를 옮 겨 다 니 며: 0 부터 x 까지 문제 의 뜻 에 부합 되 는 지 계산 하고 횟수 를 구 합 니 다.
public class SongOfXiaoQ {

    static long[][] c=new long[105][105];
    static final int mod=1000000007;
    // i    j         ,       
    private static void init(){
        //     1
        c[0][0]=1;
        for (int i=1;i<=100;i++){
            //     1
            c[i][0]=1;
            for(int j=1;j<=100;j++){
                long c1=c[i-1][j-1],c2=c[i-1][j];
                c[i][j]=(c1+c2)%mod;
            }
        }
    }

    public static void main(String[] args) {
        //    i    j        ,       
        init();
        Scanner scanner=new Scanner(System.in);
        int k=scanner.nextInt();
        int a=scanner.nextInt();
        int x=scanner.nextInt();
        int b=scanner.nextInt();
        int y=scanner.nextInt();
        long sum=0;

        for (int i=0;i<=x;i++){
            int bb=k-a*i;
            int chushub=bb/b;
            if(bb%b==0&&chushub>=0&&chushub<=y){
                sum+=c[x][i]*c[y][chushub];
            }
        }
        System.out.println(sum%mod);
    }

}

4 화가
화가 소 Q 는 또 그의 예술 창작 을 시작 했다.작은 Q 는 NxM 픽 셀 이 있 는 패 널 을 꺼 냈 다. 패 널 의 초기 상 태 는 공백 이 었 고 'X' 로 표시 했다.작은 Q 는 독특한 회화 기법 을 가지 고 있 습 니 다. 매번 에 작은 Q 는 사선 을 선택 합 니 다. 만약 에 사선 의 방향 이 '/', 즉 경사 율 이 1 이면 작은 Q 는 이 사선 중의 한 칸 을 선택 하여 파란색 으로 칠 하고 'B' 로 표시 합 니 다.만약 대각선 의 방향 이 '예', 즉 경사 율 이 - 1 이면 작은 Q 는 이 사선 의 한 칸 을 선택 하여 노란색 으로 칠 하고 'Y' 로 표시 합 니 다.한 칸 이 파란색 으로 칠 하고 노란색 으로 칠 하면 이 칸 은 녹색 으로 변 한다. 'G' 로 표시 한다.작은 Q 는 이미 그 리 려 고 하 는 작품의 모습 이 있 으 니, 그 가 적어도 몇 번 의 조작 으로 이 그림 을 완성 해 야 하 는 지 계산 해 주세요.
입력 설명:
입력 마다 테스트 용례 가 포함 되 어 있 습 니 다.각 테스트 용례 의 첫 줄 은 두 개의 정수 N 과 M (1 < = N, M < = 50) 을 포함 하여 화판 의 길 이 를 나타 낸다.다음 N 줄 은 N 개의 길이 가 M 인 문자열 을 포함 하 는데 그 중에서 문자 'B', 'Y', 'G', 'X' 를 포함 하여 각각 파란색, 노란색, 녹색, 공백 을 나타 낸다.전체적으로 소 Q 가 완성 해 야 한 다 는 것 을 나타 내 는 작품.
출력 설명:
작은 Q 가 최소한 몇 번 의 조작 으로 그림 을 완성 해 야 하 는 지 를 나타 내 는 정수 하 나 를 출력 합 니 다.
입력 예 1:
4 4 YXXB XYGX XBYY BXXY
출력 예 1:
3
예 설명 1:
XXXX XXXX XXXX XXXX -> YXXX XYXX XXYX XXXY -> YXXB XYBX XBYX BXXY -> YXXB XYGX XBYY BXXY
public class PainterXiaoQ {
    static int n, m;
    static char[][] canvas = new char[60][60];//  ,          1-50
    static int min = 0;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        scanner.nextLine();
        for (int i = 0; i < n; i++) {
            String str = scanner.nextLine();
            char[] chars = str.toCharArray();
            for (int j = 0; j < m; j++) {
                canvas[i][j] = chars[j];
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int temp = canvas[i][j];
                if (temp == 'B') {
                    encounterB(i, j);
                }
                if (temp == 'Y') {
                    encounterY(i, j);
                }
                if (temp == 'G') {
                    encounterB(i, j);
                    encounterY(i, j);
                }
            }
        }
        System.out.println(min);
    }

    static void encounterB(int x, int y) {
        canvas[x][y] = 'X';
        int ii = x + 1, jj = y - 1;
        //  while   ,   (canvas[ii][jj] == 'B' || canvas[ii][jj] == 'G'),      
        while (ii >= 0 && jj >= 0 && ii < n && jj < m && (canvas[ii][jj] == 'B' || canvas[ii][jj] == 'G')) {
            if (canvas[ii][jj] == 'B') {
                canvas[ii][jj] = 'X';
            } else {
                canvas[ii][jj] = 'Y';
            }
            ii++;
            jj--;
        }
        //  while        ,min  ++
        min++;
    }

    static void encounterY(int x, int y) {
        int ii = x + 1, jj = y + 1;
        //  while   ,   (canvas[ii][jj] == 'B' || canvas[ii][jj] == 'G'),      
        while (ii >= 0 && jj >= 0 && ii < n && jj < m && (canvas[ii][jj] == 'Y' || canvas[ii][jj] == 'G')) {
            if (canvas[ii][jj] == 'Y') {
                canvas[ii][jj] = 'X';
            } else {
                canvas[ii][jj] = 'B';
            }
            ii++;
            jj++;
        }
        //  while        ,min  ++
        min++;
    }
}

5 기계 배치
작은 Q 의 회 사 는 최근 에 m 개의 임 무 를 받 았 습 니 다. i 번 째 임 무 는 xi 의 시간 이 필요 합 니 다. 난이도 등급 은 yi 입 니 다.작은 Q 는 n 대의 기 계 를 가지 고 있 으 며, 기계 당 최 장 근무 시간 zi, 기계 등급 wi.한 가지 임무 에 대해 서 는 기계 한 대 에 만 맡 길 수 있 습 니 다. 만약 에 기계 에 배 치 된 최 장 작업 시간 이 임무 에 필요 한 시간 보다 적 으 면 완성 할 수 없습니다. 이 임 무 를 완성 하면 200 * xi + 3 * yi 수익 을 얻 을 수 있 습 니 다.
한 대의 기계 에 대해 서 는 하루 에 한 가지 임 무 를 완성 할 수 있 을 뿐, 만약 그것 의 기계 등급 이 그것 에 게 배정 한 임무 의 난이도 등급 보다 낮 으 면 완성 할 수 없다.
소 Q 는 오늘 가능 한 한 임 무 를 완수 하고 싶 습 니 다. 즉, 완수 한 임무 의 수량 이 가장 많 습 니 다.여러 가지 방안 이 있다 면, 소 Q 는 수익 이 가장 큰 방안 을 찾 고 싶 어 한다.작은 Q 는 네가 그 가 계산 하 는 것 을 도와 줄 필요 가 있다.
입력 설명:
입력 은 N + M + 1 줄 을 포함 하고 입력 한 첫 번 째 행 위 는 두 개의 정수 n 과 m (1 < = n, m < = 100000) 로 기계 의 수량 과 작업 의 수량 을 표시 합 니 다.다음 n 줄, 줄 당 두 개의 정수 zi 와 wi (0 < zi < 1000, 0 < = wi < = 100) 는 각 기계 의 최대 작업 시간 과 기계 등급 을 나타 낸다.다음 m 줄 은 줄 당 두 개의 정수 xi 와 yi (0 < xi < 1000, 0 < = yi < = 100) 로 각 퀘 스 트 에 필요 한 완성 시간 과 퀘 스 트 의 난이도 등급 을 표시 합 니 다.
출력 설명:
두 개의 정 수 를 출력 하여 각각 최대 완성 할 수 있 는 작업 수량 과 얻 을 수 있 는 수익 을 나타 낸다.
입력 예 1:
1 2 100 3 100 2 100 1
출력 예 1:
1 20006
import java.util.*;

/**
 * @Auther: 
 * @Date: 2018/8/30 16:02
 * @Description:     
 */
public class ArrangeMachine {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int m=scanner.nextInt();
        ArrayList arrayList1=new ArrayList<>(n);//      
        for (int i=0;i arrayList2=new ArrayList<>(m);//      
        for (int i=0;i=arrayList2.get(i).getX()){
                degree[arrayList1.get(j).getY()]++;
                j++;
            }
            for (int k=arrayList2.get(i).getY();k<=100;k++){//          ,       
                if(degree[k]>0){
                    num++;
                    degree[k]--;
                    profit+=arrayList2.get(i).getX()*200+arrayList2.get(i).getY()*3;
                    break;
                }
            }
        }
        System.out.println(num+" "+profit);
    }

    //    ,         ,        
    private static void sort(ArrayList arrayList1){
        Collections.sort(arrayList1, new Comparator() {
            @Override
            public int compare(TimeAndDegree a, TimeAndDegree b) {
                if(b.getX()==a.getX())
                    return b.getY()-a.getY();
                return b.getX()-a.getX();
            }
        });
    }
}

class TimeAndDegree{
    public TimeAndDegree(){}
    public TimeAndDegree(int x,int y){
        this.x=x;
        this.y=y;
    }

    private int x;//0-1000
    private int y;//0-100

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }


}

좋은 웹페이지 즐겨찾기