奇虎360 2017春招真题

剪气球串（奇虎360 2017春招真题）

题目描述

小明买了一些彩色的气球用绳子串在一条线上，想要装饰房间，每个气球都染上了一种颜色，每个气球的形状都是各不相同的。我们用1到9一共9个数字表示不同的颜色，如12345则表示一串5个颜色各不相同的气球串。但小明希望得到不出现重复颜色的气球串，那么现在小明需要将这个气球串剪成多个较短的气球串，小明一共有多少种剪法？如原气球串12345的一种是剪法是剪成12和345两个气球串。注意每种剪法需满足最后的子串中气球颜色各不相同（如果满足该条件，允许不剪，即保留原串）。两种剪法不同当且仅当存在一个位置，在一种剪法里剪开了，而在另一种中没剪开。详见样例分析。
​ `

输入第一行输入一个正整数n（1≤n≤100000），表示气球的数量。第二行输入n个整数a1，a2，a3…an，ai表示该气球串上第i个气球的颜色。对于任意i，有1≤ai≤9。	样例输入31 2 3
输出输出一行，第一行输出一个整数，表示满足要求的剪法，输出最终结果除以1000000007后的余数。	样例输出4
时间限制C/C++语言：2000MS其它语言：4000MS	内存限制C/C++语言：131072KB其它语言：655360KB

解析：对于剪气球这道题，很显然，当我们遇到一个这样的数据串[1, 2, 1, 2]

1. 枚举从后边向前剪的种数，设当前串可以剪的种数为f(n)（n为从0位开始的长度）
2. 则对于[1, 2, 1, 2]的可以减的种数为f(4) = f(3)[对应[1, 2, 1], 2] + f(2)[对应[1, 2], (12)]这种
3. 对于子串[1, 2, 1]可以剪的种数为f(3) = f(2)[对应[1, 2], 1] + f(1)[对应1, (21)]
4. 对应子串[1, 2]可以剪的种数为f(2) = f(1) [对应1, 2] + f(0)[对应null, 12]
5. 从上边我们可以看出如果我们使用递归的方法计算的话，整个算法可能会重复计算很多重复的过程，所以我们可以使用数组来保存我们计算出的f(n)，从而达到提高效率的方法

源码：

底下的递归方式的数据格式为从0 - n - 1为数据域，与循环方式不同，递归方式当有1000个气球的时候，会超出时间限制（很尴尬）

import java.util.Arrays;
import java.util.Scanner;

/**
 * Created by no_clay on 2017/3/18.
 */
public class Main1 {
    public static final int MOD = 1000000007;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int []data = null;
        int len = scanner.nextInt();
        if (len <= 0){
            return;
        }else{
            data = new int[len + 1];
            int count = 0;
            for (int i = 1; i <= len && scanner.hasNext(); i++) {
                data[i] = scanner.nextInt();
                count ++;
            }
            if (count < len){
                return;
            }
        }
        int[]pos = new int[len + 1];
        pos[0] = 1;
        int[] number = new int[11];
        for (int i = 1; i <= len; i++) {
            Arrays.fill(number, 0);
            for (int j = 0; j < i; j++) {
                number[data[i - j]] ++;
                if (number[data[i - j]] > 1){
                    break;
                }
                pos[i] = (pos[i - j - 1] + pos[i]) % MOD;
            }
        }
        System.out.println(pos[len]);
    }

    public static int count(int[] data, int[] pos, int end){
        int[] number = new int[10];
        int count = 0;
        if (end <= 0){
            return 1;
        }
        for (int i = end - 1; i >= 0; i--) {
            if (number[data[i]] == 0){
                if (pos[i] != 0){
                    count += pos[i];
                }else {
                    count += count(data, pos, i);
                }
                number[data[i]] ++;
            }else {
                break;
            }
        }
        pos[end] = count;
        return count;
    }
}

分金子（奇虎360 2017春招真题）

题目描述
A、B两伙马贼意外地在一片沙漠中发现了一处金矿，双方都想独占金矿，但各自的实力都不足以吞下对方，经过谈判后，双方同意用一个公平的方式来处理这片金矿。处理的规则如下：他们把整个金矿分成n段，由A、B开始轮流从最左端或最右端占据一段，直到分完为止。 马贼A想提前知道他们能分到多少金子，因此请你帮忙计算他们最后各自拥有多少金子?（两伙马贼均会采取对己方有利的策略）
​ `

输入测试数据包含多组输入数据。输入数据的第一行为一个正整数T(T<=20)，表示测试数据的组数。然后是T组测试数据，每组测试数据的第一行包含一个整数n，下一行包含n个数（n <= 500 ），表示每段金矿的含金量，保证其数值大小不超过1000。	样例输入2 64 7 2 9 5 210140 649 340 982 105 86 56 610 340 879
输出对于每一组测试数据，输出一行”Case #id: sc1 sc2”，表示第id组数据时马贼A分到金子数量为sc1，马贼B分到金子数量为sc2。详见样例。	样例输出Case #1: 18 11Case #2: 3206 981
时间限制C/C++语言：1000MS其它语言：3000MS	内存限制

源码：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        solve();
    }

    private static void solve() {
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        for (int i=1; i<=num; i++){
            int n = in.nextInt();
            // 记录n份金子
            int[] array = new int[n+1];
            // 前i份金子的数量之和
            int[] sum = new int[n+1];
            array[0] = 0;
            sum[0] = 0;
            for (int j=1; j<=n; j++) {
                array[j] = in.nextInt();
                sum[j] = sum[j-1] + array[j];
            }
            // 动态规划数组
            int[][] f = new int[n+1][n+1];
            for (int j=1; j<=n; j++)
                // 记录对角线元素
                f[j][j] = array[j];
            int k=1;
            while (k <= n-1){
                // 从对角线元素开始计算，向右上挪动直至计算完f[1][n]
                for (int j=1; j+k<=n; j++){
                    f[j][j+k] = sum[j+k] - sum[j-1] - Math.min(f[j][j+k-1], f[j+1][j+k]);
                }
                k++;
            }
            System.out.println("Case #"+i+": "+f[1][n]+" "+(sum[n]-f[1][n]));
        }
        in.close();
    }
}