ACM入门:第s名的小红

　　前几天的大一新生赛自己也跟着做了做，顺便测测后台数据有没有bug，这是一道排序题，题目如下：

Problem Description

小红总是排第二，有点不服气，现在她想知道一个序列中第二小的数字是多少，你能告诉她么。

Input

输入包含多组测试样例，每组测试样例分为两行，第一行一个n(0 < n <= 10000),代表序列有n个数字，第二行输入n个正整数ai(0 <= ai <= 10^6)。

Output

每组输出到一行上，如果找到了第二小的数 x,输出它，如果没找到，输出"No find",没有引号。

Sample Input

5
1 2 3 4 5

Sample Output

2

　题目如上，看到题的第一反应，毫无疑问的桶排。事实上准备出来的标程也是如此，思路如下：
　由于n的范围为0~1e6，所以开一个长度为一百万的一维数组（初始化为0），数组下标与出现过的数字相对应，数字每出现过一次，对应的数组元素值重置为1，循环输入完成后，另开一圈循环，从0开始，直到找到第二个数组元素对应值为1的元素，输出其下标，即为所求。

　　
　代码如下：

#include<stdio.h>
int main()
{
　　int n;
　　while (~scanf("%d",&n))
　　{
　　　　int a[1000000]={0};
　　　　for(int i=0;i<n;i++)
　　　　{
　　　　　　int k;
　　　　　　scanf("%d",&k);
　　　　　　a[k]=1;
　　　　}
　　　　int flag=0;
　　　　for(int i=0;i<1000000;i++)
　　　　{
　　　　　　if(a[i]!=0)
　　　　　　flag++;
　　　　　　if(flag==2)
　　　　　　{
　　　　　　printf("%d\n",i);
　　　　　　break;
　　　　　　}
　　　　}
　　　　if(flag!=2)
　　　　printf("No find\n");
　　}
}

　　结果自然是ac了，然而缺点是内存开的太大了。so。。。小开了一波脑洞，思路如下：

　　既然是只输出第二位元素，那么只进行简单的排序，输出第二位不就好了，那么利用冒泡排序的思想，只让两个元素沉底之后输出第二个不就好了，然而这个算法有一个非常明显的bug，就是对于相同元素的情况处理，假设有两个或者两个以上的最小元素沉底的话，如：5 1 1 2 3 4 ，那么最小的数有两个即两个1，那么循环会执行两次外层循环，结果为 2 3 4 1 1，那么结果很明显是错误的。那么只要在判断与上一个已经沉底的元素相同的话，改变i值，执行i--，使得外层循环强行增加一次。后来这种想法被舍弃了，原因有两个，第一，数组下标实在是太难计算了，而且下标计算出错改错也很困难。第二，如果是特殊数据的话，例如 5 1 1 1 1 2，那么时间复杂度就会变成O(n²)，所以并不可取（实际上是因为数组下标算烦了）。。。

　   不过在算数组下标的时间里，又诞生了一种想法，既然是找到第二小的元素，那么只要找到最小的元素，除去最小的元素以外的元素里剩下的部分，其中最小的元素不就是第二小的了么，而且这样实现的话，对于元素除重的问题也很好解决。不过还是要从同到尾遍历两次数组，那么是否可以将其塞到一层循环里呢（输入完数据后不再经历循环），答案当然是可以的（如果我没实现出来就不在文里提了。。。）思路如下：

　　在输入一个数组元素后用两个变量记录下当前扫过的最小值和仅次于最小值的值，遍历数组后直接输出就好。代码如下：

#include<stdio.h>
int main()
{
　　int a[10005];
　　int n;
　　while (~scanf("%d",&n))
　　{
　　　　int flag=0;
　　　　int flag2=0;
　　　　int min1=10001;
　　　　int min2=10001;
　　　　for(int i=0; i<n; i++)
　　　　{
　　　　　　scanf("%d",&a[i]);
　　　　　　if(a[i]<min1)
　　　　　　{
　　　　　　　　min2=min1;
　　　　　　　　min1=a[i];
　　　　　　}
　　　　　　else if(a[i]!=min1&&a[i]<min2)
　　　　　　　　min2=a[i];
　　　　}
　　　　if(min2==10001)
　　　　　　printf("No find\n");
　　　　else
　　　　　　printf("%d\n",min2);
　　}
}

　　这样的话内存就小了很多，相比桶排的实现，内存上还是存在一定程度上的优化的，而且如果是桶排，局限性也得到了解决（题目限制数据输入不超过1e6如果是1e15这样的数据范围，一维数组的内存申请就会出错）

　　但是这是求第二小的元素，如果是第n小呢，即便我可以写到第n个min，也不可能写出那么多的else if（）啊。。。所以我开始继续改良我的“冒泡版”算法。

　　鉴于之前的遇到重复元素的处理既费时又费力。。。所以新的处理办法思路如下：

　　对于存在重复元素的数据，如果重复的元素本身并不是第二小，或者第一小，不用考虑，如果是，那么设置条件，当前的元素必须不等于已经沉底的元素，而且小于下一个元素的时候才执行元素互换。代码如下：

#include<stdio.h>
int main()
{
　　int n;
　　while (~scanf("%d",&n))
　　{
　　　　int a[10000];
　　　　int flag=-1;
　　　　int j;
　　　　int flag2=0;
　　　　for(int i=0; i<n; i++)
　　　　{
　　　　　　scanf("%d",&a[i]);
　　　　　　if(flag2||a[i]!=a[0])
　　　　　　flag2=1;
　　　　}
　　　　for(int i=0; i<2; i++)
　　　　{
　　　　　　for(j=0; j<n-1-i; j++)
　　　　　　　　if((a[j]<a[j+1]||a[j+1]<=flag)&&a[j]>flag)
　　　　　　　　{
　　　　　　　　　　int t=a[j];
　　　　　　　　　　a[j]=a[j+1];
　　　　　　　　　　a[j+1]=t;
　　　　　　　　}
　　　　flag=a[j];
　　　　}
　　　　if(flag2)
　　　　　　printf("%d\n",a[n-2]);
　　　　else
　　　　　　printf("No find\n");
　　}
}

　　ac...算是把一开始脑洞搬到电脑上了。。。然而。。。刚填完一个脑洞，又开了一个：能不能实现它的推广呢，即题目那样，可以任意改变第几小。继续想需要改动的地方，想了一圈。唯一的难点是No find，因为不能在输入的时候直接判定有几个不同元素了，这个问题困扰了好一阵，大致思路还是想塞到输入的那层for里，但是直到现在也没用这种方法实现。所以转了一种思路，把这个判定放到别的地方去，思路如下：

　　每次外层循环结束，即有元素沉底后，判断这个刚刚沉底的元素和倒数第二个沉底的元素的关系，正常情况下，应该是刚刚沉底的元素大于倒数第二个沉底的元素，而非正常情况下，也就是No find时，这个刚刚沉底的元素一定会小于等于倒数第二个沉底的元素。代码如下：

#include<stdio.h>
#define s 2
int main()
{
    int n;
    while (~scanf("%d",&n))
    {
        int a[10000];
        int flag=-1;
        int flag2=0;
        int flag3=0;

　   　int  j;
        for(int i=0; i<n; i++)
            scanf("%d",&a[i]);
        for(int i=0; i<s; i++)
        {
            for(j=0; j<n-1-i; j++)
            {
                if((a[j]<a[j+1]||a[j+1]<=flag)&&a[j]>flag)
                {
                    int t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
            if(a[j]<=flag)
            {
                flag3=1;
                break;
            }
            flag=a[j];
        }
        if(!flag3)
            printf("%d\n",a[n-s]);
        else
            printf("No find\n");
    }
}

　　比赛的后台并没有这样的测试样例，so。。。没有结果返回了，不过自己把想到的数据都测了，结果无误。
　　至此，脑洞已全部填完。。。