2017 今日头条编程题汇总：

头条的2017校招开始了！为了这次校招，我们组织了一个规模宏大的出题团队，每个出题人都出了一些有趣的题目，而我们现在想把这些题目组合成若干场考试出来，在选题之前，我们对题目进行了盲审，并定出了每道题的难度系统。一场考试包含3道开放性题目，假设他们的难度从小到大分别为a,b,c，我们希望这3道题能满足下列条件： 
a<=b<=c 
b-a<=10 
c-b<=10 
所有出题人一共出了n道开放性题目。现在我们想把这n道题分布到若干场考试中（1场或多场，每道题都必须使用且只能用一次），然而由于上述条件的限制，可能有一些考试没法凑够3道题，因此出题人就需要多出一些适当难度的题目来让每场考试都达到要求，然而我们出题已经出得很累了，你能计算出我们最少还需要再出几道题吗？ 
输入描述: 
输入的第一行包含一个整数n，表示目前已经出好的题目数量。

第二行给出每道题目的难度系数d1,d2,…,dn。

数据范围 
对于30%的数据，1 ≤ n,di ≤ 5; 
对于100%的数据，1 ≤ n ≤ 10^5,1 ≤ di ≤ 100。 
在样例中，一种可行的方案是添加2个难度分别为20和50的题目，这样可以组合成两场考试：（20 20 23）和（35,40,50）。 
输出描述: 
输出只包括一行，即所求的答案。

输入例子1: 
4 
20 35 23 40

输出例子1: 
2

解析： 思路 第一步：进行排序将输入的难度进行排序处理

　　　　第二步： 首先看 a1,a2,a3 ---这三个数进行比较，确定 添加的题目数

FIRST: 如果 a2-a1<=10 && a3-a2<=10 符合要求，从a4,a5,a6下三组进行开始

SECOND：如果 a2-a1>10 && a2-a1<=20 数量+1，跳到第三个从 a3,a4,a5开始

THIRD：如果a2-a1>20 则所在数量+2，从a2,a3,a4 开始

FORTH：如果a2-a1<=10 ,并且 a3-a2>10 则数量+1，a3,a4,a5 下一组开始

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

/**
 * Created by Workstation on 2017/8/21.
 */
public class Main {

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

    }

    public static void test_1()
    {
        Scanner in=new Scanner (System.in);

        int M=in.nextInt ();
        int[] arr=new int[M];
        for(int i=0;i<M;i++)
        {
            arr[i]=in.nextInt ();// 依次将输入的结果进行排序
        }
        Arrays.sort (arr);

        //进行处理
        int count=0,index=0;
        int n=arr.length;
        while(index<arr.length)
        {
            if((index+1<n) && (index+2)<n && arr[index+1]-arr[index]<=10)
            {
                if(arr[index+2]-arr[index+1]<=10)// 属于第一种情形
                {
                    index+=3;
                }else // a3-a2>10
                {
                    count+=1;
                    index+=2;// 从 a2,a3,a4开始
                }
            }else if(index+1<n && arr[index+1]-arr[index]<=20)
            {
                count+=1;
                index+=2;
            }else 
            {
                count+=2;
                index+=1;
            }
        }
        if(index==n-1) count+=2;
        System.out.println(count);
    }
}

给定整数m以及n各数字A1,A2,..An，将数列A中所有元素两两异或，共能得到n(n-1)/2个结果，请求出这些结果中大于m的有多少个。 

输入描述:

第一行包含两个整数n,m. 

第二行给出n个整数A1，A2，...，An。

数据范围

对于30%的数据，1 <= n, m <= 1000

对于100%的数据，1 <= n, m, Ai <= 10^5

输出描述:

输出仅包括一行，即所求的答案

示例1

输入

3 10  
6 5 10

解析：

引入 概念T：Trie树，单词树，主要用于 字符串的查找和前缀匹配，
利用串构建一个字典树，该字典树保留串的公共的前缀西欧爱心，以英文字母为例子： 每一个Trie树 中每一个节点包含26个孩子节点，：

如下给出字符串"abc","ab","bd","dda"，根据该字符串序列构建一棵Trie树。则构建的树如下：Trie树根节点不包含任何信息，第一个字符串"abc" 第一个

字母a，因此在根节点数组中找到字符串下标a-97 数组下标的值不为NULL就行，同样依次类推：查找字符串“abc“ 查找的长度olog(Len) ,采用匹配耗时间哦(n*len)

解题：使用Tire树，将n个数字分别装换成二进制形式进行存储到Trie树，比较a[i]元素和m对应二进制每一位的比值：
数据最多10^5 对于每一个节点 使用1<< 17 才能够满足哦，因此需要空间10^5*17 byte= 大概是210KB左右的空间； 
有用的东西：和1异或相当于该位上的数进行取反，同时a^b=c有 a^c=b:

这一道题：可以摆每一个数的二进制求出来，用一个字典树进行维护，之后遍历每一个数按照位的贪心算法进行：
1.如果这一位对应位m是1，那么与此位相异或必须是1，如果这一位m是0，要大于m的话异或的这一位可以是1或者是0，ans加上之前维护过的二进制位加上这一位为1的数在字典树中查询到有多小满足这个前缀的条件，之后让这一位的异或为0，继续往下遍历，最后除以2
图如下所示 当前m=0:想大于m这一位相与必须要是1，m=1 只能递归判断下一位

直接计算肯定是超时的，所以这问题不能使用暴力破解，考虑到从高位到地位，依次进行位运算，如果两个数异或结果在某高位为1，而m的对应位为0，则肯定任何这两位异或结果为1的都会比m大。 直接从高到低位进行判断

由此，考虑使用字典树（TrieTree）从高位到第位建立字典，再使用每个元素依次去字典中查对应高位异或为1， 而m为0的数的个数，相加在除以2既是最终的结果；直接贴出代码如下，非原创，欢迎讨论；

补充：queryTrieTree在搜索的过程中，是从高位往低位搜索，那么，如果有一个数与字典中的数异或结果的第k位大于m的第k位，那么该数与对应分支中所有的数异或结果都会大于m， 否则，就要搜索在第k位异或相等的情况下，更低位的异或结果。queryTrieTree中四个分支的作用分别如下： 当mDigi位为1 的时候不得不递归d下一位

1. aDigit=1， mDigit=1时，字典中第k位为0，异或结果为1，需要继续搜索更低位，第k位为1，异或结果为0，小于mDigit，不用理会；

2. aDigit=0， mDigit=1时，字典中第k位为1，异或结果为1，需要继续搜索更低位，第k位为0，异或结果为0，小于mDigit，不用理会；

 

3. aDigit=1， mDigit=0时，字典中第k位为0，异或结果为1，与对应分支所有数异或，结果都会大于m，第k位为1，异或结果为0，递归获得结果；

4. aDigit=0， mDigit=0时，字典中第k位为1，异或结果为1，与对应分支所有数异或，结果都会大于m，第k位为0，异或结果为0，递归获得结果；

import java.util.Scanner;
 
public class Main {
    private static class TrieTree {
        TrieTree[] next = new TrieTree[2];
        int count = 1;
    }
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()){
            int n = sc.nextInt();
            int m = sc.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = sc.nextInt();
            }
            System.out.println(solve(a, m));
        }
    }
 
    private static long solve(int[] a, int m) {
        TrieTree trieTree = buildTrieTree(a);
        long result = 0;
        for (int i = 0; i < a.length; i++) {
            result += queryTrieTree(trieTree, a[i], m, 31);
        }
        return result / 2;
    }
 
    private static long queryTrieTree(TrieTree trieTree, int a, int m, int index) {
        if(trieTree == null)
            return 0;
 
        TrieTree current = trieTree;
        for (int i = index; i >= 0; i--) {
            int aDigit = (a >> i) & 1;
            int mDigit = (m >> i) & 1;
            if(aDigit == 1 && mDigit == 1) {
                if(current.next[0] == null)
                    return 0;
                current = current.next[0];
            } else if (aDigit == 0 && mDigit == 1) {
                if(current.next[1] == null)
                    return 0;
                current = current.next[1];
            } else if (aDigit == 1 && mDigit == 0) {
                long p = queryTrieTree(current.next[1], a, m, i - 1);
                long q = current.next[0] == null ? 0 : current.next[0].count;
                return p + q;
            } else if (aDigit == 0 && mDigit == 0) {
                long p = queryTrieTree(current.next[0], a, m, i - 1);
                long q = current.next[1] == null ? 0 : current.next[1].count;
                return p + q;
            }
        }
        return 0;
    }
 
    private static TrieTree buildTrieTree(int[] a) {
        TrieTree trieTree = new TrieTree();
        for (int i = 0; i < a.length; i++) {
            TrieTree current = trieTree;
            for (int j = 31; j >= 0; j--) {
                int digit = (a[i] >> j) & 1;
                if(current.next[digit] == null) {
                    current.next[digit] = new TrieTree();
                } else {
                    current.next[digit].count ++;
                }
                current = current.next[digit];
            }
        }
        return trieTree;
    }
}

 输入 1-n的数字按照字典进行排序 

给定整数n和m, 将1到n的这n个整数按字典序排列之后, 求其中的第m个数。
对于n=11, m=4, 按字典序排列依次为1, 10, 11, 2, 3, 4, 5, 6, 7, 8, 9, 因此第4个数是2. 
对于n=200, m=25, 按字典序排列依次为1 10 100 101 102 103 104 105 106 107 108 109 11 110 111 112 113 114 115 116 117 118 119 12 120 121 122 123 124 125 126 127 128 129 13 130 131 132 133 134 135 136 137 138 139 14 140 141 142 143 144 145 146 147 148 149 15 150 151 152 153 154 155 156 157 158 159 16 160 161 162 163 164 165 166 167 168 169 17 170 171 172 173 174 175 176 177 178 179 18 180 181 182 183 184 185 186 187 188 189 19 190 191 192 193 194 195 196 197 198 199 2 20 200 21 22 23 24 25 26 27 28 29 3 30 31 32 33 34 35 36 37 38 39 4 40 41 42 43 44 45 46 47 48 49 5 50 51 52 53 54 55 56 57 58 59 6 60 61 62 63 64 65 66 67 68 69 7 70 71 72 73 74 75 76 77 78 79 8 80 81 82 83 84 85 86 87 88 89 9 90 91 92 93 94 95 96 97 98 99 因此第25个数是120…

public class Main {
　　// 使用一点小手段计算结果只有80% 的通过，说明这个算法还是可以进行调整
    public static void main (String[] args) {

       Scanner in=new Scanner (System.in);
        Long n=in.nextLong ();
        Long m=in.nextLong ();
        int cur=1;
        for(int i=1;i<m;i++)
        {
            if(cur*10<=n)
            {
                cur*=10;// 进行扩展位
            }else
            {
                if(cur>=n) cur=cur/10;//防止越界
                cur+=1;
                while(cur%10==0) cur/=10;
            }
        }
        System.out.println(cur);
    }
    
}

 

找出函数的最宽尖峰

【题目描述】按数组的形式给出函数f(x)的取值，即数组A的A[0]元素为f(0)的取值，数组的取值都为整数，函数在每个点都是严格单调递增或者严格递减（即A[i-1] != A[i] != A[i+1]），要求找出最宽的先上升后下降的区间（这个区间内函数的值必须先上升到一个点然后下降，区间的上升段和下降段长度必须都大于0）。

1. 如果找到符合条件的最大区间输出数组对应的左右下标（保证只有一个最大区间）

2. 找不到那么输出-1 -1

输入格式

n

n长度的整数数组

 

输出格式

区间的范围

 

输入样例

10

1 3 1 2 5 4 3 1 9 10

 

输出样例

2 7

 

数据规模

对于 100% 的数据，1 <=n <=10, 000, 000

解析：此题有点类似与排队序列相似

public static void test_4()
    {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt ();
        int [] x=new int[n];

        for(int i=0;i<n;i++)
            x[i]=in.nextInt ();

        int [] dpL=new int[n];

        for(int i=1;i<n;i++)
        {
            if(x[i]-x[i-1]>0)
            {
                dpL[i]=dpL[i-1]+1;
            }
        }

        int [] dpR=new int[n];

        for(int i=n-2;i>=0;i--)
        {
            if(x[i]-x[i+1]>0)
            {
                dpR[i]=dpR[i+1]+1;
            }
        }

        int mx=0,LL=-1,RR=-1;
        for(int i=0;i<n;i++)
        {
            if(dpL[i]>0 && dpR[i]>0 && dpL[i]+dpR[i]>mx)
            {
                mx=dpL[i]+dpR[i];
                LL=i-dpL[i];
                RR=i+dpR[i];
            }
        }
        System.out.println(LL+" "+RR);
    }

 

Paragraph

【问题描述】给定一个段落，由 N 个句子组成。第 i 个句子的长度为 L[i]，包含的单词个数为 W[i]。

句子不包含任何除字母和空格( ) 外的符号。

每个句子内部，含有若干个单词，由空格( ) 分隔。句子不会包含连续的空格。

随后给定 M 个查询，每个查询包含一个句子，需要在段落中寻找相同单词数量最多的句子。重复的单词只计一次，且不区分大小写。

输入数据将保证结果是存在且唯一的。

 

输入格式

第一行是两个整数 N 和 M。

接下来的 N+M 行，每行包含一个句子。

前 N 行代表段落中的句子，后 M 行表示查询。

 

输出格式

输出 M 行，每行代表查询的结果。

 

输入样例

6 3

An algorithm is an effective method that can be expressed within a finite amount of space and time

Starting from an initial state and initial input the instructions describe a computation

That when executed proceeds through a finite number of successive states

Eventually producing output and terminating at a final ending state

The transition from one state to the next is not necessarily deterministic

Some algorithms known as randomized algorithms incorporate random input

Next to the transition

Wormhole, infinite time and space

The transition from one state to the next is not necessarily deterministic

 

输出样例

The transition from one state to the next is not necessarily deterministic

An algorithm is an effective method that can be expressed within a finite amount of space and time

The transition from one state to the next is not necessarily deterministic

 

数据规模

0 < L[i] < 512

0 < W[i] < 32

对于 30% 的数据，0 < N < 30，0 < M < 30。

对于 100% 的数据，0 < N < 500，0 < M < 800。

package com.mmall.common.program;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;

/**
 * Created by Workstation on 2017/8/23.
 *
 * 字符串的处理问题： 从给定的句子和一段语句，从给定句子中查找到段落中相同的语句
 */
public class jiri_4 {
    public static void main (String[] args) {
        Scanner sc=new Scanner (System.in);

        int n=sc.nextInt ();
        int m=sc.nextInt();

        // 向下输入zifuchuan
        sc.nextLine ();

        String[] senetences=new String[n];
        for(int i=0;i<n;i++)
        {
            senetences[i]=sc.nextLine ();
        }

        List<HashSet<String>> sentenceList=new ArrayList<> ();
        for(int i=0;i<n;i++)
        {
            HashSet<String> set=new HashSet<> ();
            String[] temp=senetences[i].toLowerCase ().split (" ");
            for(String s:temp)
            {
                set.add(s);
            }
            sentenceList.add(set);
        }

        for(int i=0;i<m;i++)
        {
            HashSet<String> set = new HashSet<>();
            String[] temp = sc.nextLine().toLowerCase().split(" ");
            for (String s : temp) {
                set.add(s);
            }
            // 遍历List 找到最大相同的单词
            int max=0,maxIndex=0;

            for(int j=0;j<n;j++)
            {
                HashSet<String> targetSentence=sentenceList.get(j);
                int count=0;
                for(String s:set)
                {
                    if(targetSentence.contains (s))
                    {
                        count++;
                    }
                }
                if(count>max)
                {
                    max=count;
                    maxIndex=j;
                }
                System.out.println(senetences[maxIndex]);
            }
        }
    }
}