#include <iostream>
#include <string>
 
using namespace std;
 
string greedy(string& str, int n)
{
	bool del;
	for (int i = n; i > 0; i--)
	{
		del = false;
		// 每次删除第一个比下一个数字大的数
		for (string::iterator it = str.begin(); it != str.end()-1; it++)
		{
			if (*it > *(it+1))
			{
				str.erase(it);
				del = true;
				break;
			}
		}
		//如果所有数字递增，则删除最后几个数字直接返回
		if (!del)
		{
			str.erase(str.end()-i, str.end());
			break;
		}
	}
	return str;
}
 
int main()
{
	int n;
	string str;
	cin >> str;
	cin >> n;
 
	cout << greedy(str, n) << endl;
 
	return 0;
}

#include <iostream>
#define SIZE 10
 
using namespace std;
 
int size1(int array[SIZE])
{
	return sizeof(array);
}
 
int size2(int (&array)[SIZE])
{
	return sizeof(array);
}
 
int main()
{
	int array[SIZE];
	cout << sizeof(array) << endl;
	cout << size1(array) << endl;
	cout << size2(array) << endl;
	return 0;
}

#include "stdafx.h"
#include <iostream>
#include <string>
 
using namespace std;
 
class Demo
{
public:
	string objName;
	Demo(string Name)
	{
		this->objName = Name;
		cout << objName << " Constructor called" << endl;
	}
	~Demo()
	{
		cout << objName << "Destructor called" << endl;
	}
};
 
Demo obj1("obj1");
 
int main()
{
	cout << "Main() start" << endl;
	Demo obj2("obj2");
	return int(&(cout << "Main() end" << endl));
}

#include <iostream>
 
using namespace std;
 
int partition(int[], int, int);
int Select(int[], int, int, int); 
 
int main()
{
	int n, m;
	int l, r, k;
	int v[100002];
	int d[100002];
	cin >> n >> m;
	for (int i = 1; i <= n; i++) cin >> v[i];
	while (m--)
	{
		cin >> l >> r >> k;
		for (int j = l; j <= r; j++) d[j] = v[j];
		cout << Select(d, l, r, k) << endl;
	}
 	return 0;
}
 
//一次快速排序 
int partition(int s[], int l, int r)
{
	if (l < r)
	{
		int i = l;
		int j = r;
		int x = s[i];
		while (i < j)
		{
			while (i < j && s[j] > x) j--;
			if (i < j) s[i++] = s[j];
			while (i < j && s[i] < x) i++;
			if (i < j) s[j--] = s[i];
		}
		s[i] = x;
		return i;
	}
	return -1;
}
 
//分治找K-th Number 
int Select(int s[], int l, int r, int k)
{
	if (l > r) return -1;
	if (l == r) return s[l];
	//得到中间数的下标 
	int i = partition(s, l, r);
	//j为左区间长度 
	int j = i - l + 1;
	//位置大就在左区间找，否则就在右区间找
	if (j == k) return s[i];
	else if (j > k) return Select(s, l, i, k);
	else return Select(s, i+1, r, k-j);
}

/*
Slyar
2009.12.1
学生成绩管理系统 C语言 
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define CLASS 6
#define MAXID 10
#define MAXNAME 15
#define MALLOC (Student*) malloc(sizeof(Student))
 
/* 学生数据结构 */
typedef struct node
{
    char id[20];
    char name[15];
    int score[CLASS];
    int sum;
    double ave;
    struct node *next;
} Student;
 
/* 头指针 */
Student *head = NULL;
/* 临时指针 */
Student *tmp = NULL;
/* 课程名称 */
char CLASSNAME[CLASS][30] = {"物理", "化学", "计算机", "英语", "数学", "体育"};
/* 命令开关 */
int SWITCH[16] = {0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
/* 函数声明 */
int Menu();
Student* Init();
int CheckID(char*);
int CheckName(char*);
int CheakScore(int score);
int IsSameID(char*);
void InputNodeInfo(Student*);
void OutputNodeInfo(Student*);
Student* SearchFrontNode(Student*);
void DeleteNode(Student*);
void InsertBefore();
void InputList();
Student* SearchID(char*);
Student* SearchName(char*);
void SearchDeleteNode();
void OutList();
void SearchPrintNode();
void Compute();
int CmpID(Student*, Student*, int);
int CmpSum(Student*, Student*, int);
int CmpScore(Student*, Student*, int);
Student* SearchMaxNode(int (*cmp)(Student*, Student*, int), int);
Student* Sort(int (*cmp)(Student*, Student*, int), int);
void OutputToFile(FILE*, Student*, int);
void InsertAfter(Student*);
void SaveToFile();
void LoadFile();
void CopyFile();
void InsertToFile();
void FreeList(Student* p);
void Stat();
void Quit();
 
/* 主函数 */
int main()
{
    int n;
 
    while (1)
    {
        n = Menu();
        {
            if (n == 1 || n == 15 || SWITCH[1])
            {
                switch (n)
                {
                        /* 执行初始化 */
                    case 1:
                        head = Init();
                        printf("初始化成功\n");
                        break;
                        /* 创建链表 */
                    case 2:
                        InputList();
                        break;
                        /* 删除记录 */
                    case 3:
                        SearchDeleteNode();
                        break;
                        /* 显示全部记录 */
                    case 4:
                        system("cls");
                        OutList();
                        break;
                        /* 查找记录 */
                    case 5:
                        SearchPrintNode();
                        break;
                        /* 保存文件 */
                    case 6:
                        SaveToFile();
                        break;
                        /* 读文件 */
                    case 7:
                        if (SWITCH[6])
                        {
                            head = Init();
                            LoadFile();
                        }
                        else
                        {
                            printf("当前文件未保存\n");
                        }
                        break;
                        /* 计算总分和均分 */
                    case 8:
                        Compute();
                        SWITCH[8] = 1;
                        printf("计算完毕\n");
                        break;
                        /* 插入记录 */
                    case 9:
                        InsertBefore();
                        SWITCH[6] = 0;
                        SWITCH[8] = 0;
                        break;
                        /* 复制文件 */
                    case 10:
                        CopyFile();
                        break;
                        /* 排序 */
                    case 11:
                        if (SWITCH[8])
                        {
                            head = Sort(CmpSum, 0);
                            system("cls");
                            OutList();
                        }
                        else
                        {
                            printf("请先计算总分!\n");
                        }
                        break;
                        /* 追加记录 */
                    case 12:
                        InsertToFile();
                        SWITCH[6] = 0;
                        printf("追加完毕!\n");
                        break;
                        /* 索引 */
                    case 13:
                        if (SWITCH[8])
                        {
                            head = Sort(CmpID, 0);
                            system("cls");
                            OutList();
                        }
                        else
                        {
                            printf("请先计算总分!\n");
                        }
                        break;
                        /* 分类合计 */
                    case 14:
                        system("cls");
                        Stat();
                        break;
                        /* 结束 */
                    case 15:
                        Quit();
                        break;
                    default:
                        printf("无效命令!\n");
                        fflush(stdin);
                }
                system("pause");
            }
            else
            {
                printf("你必须首先初始化!\n");
                system("pause");
            }
        }
    }
 
    system("pause");
    return 0;
}
 
/* 菜单 */
int Menu()
{
    int n;
    system("cls");
    fflush(stdin);
    printf("【01】 初始化\n");
    printf("【02】 输入学生信息\n");
    printf("【03】 查找学号或姓名删除信息\n");
    printf("【04】 打印全部学生信息\n");
    printf("【05】 按姓名查找学生信息\n");
    printf("【06】 保存到文件\n");
    printf("【07】 从文件中读取学生信息\n");
    printf("【08】 计算所有学生的总分和平均分\n");
    printf("【09】 插入一个学生信息到链表中\n");
    printf("【10】 复制文件\n");
    printf("【11】 按总分排序并打印学生信息\n");
    printf("【12】 追加一个学生信息到文件中\n");
    printf("【13】 按学号索引学生信息\n");
    printf("【14】 分类汇总\n");
    printf("【15】 退出\n");
    printf("请输入命令编号: ");
    scanf("%d", &n);
    return n;
}
 
/* 初始化 */
Student* Init()
{
    int i;
    Student *head;
    head = MALLOC;
    head->next = NULL;
 
    /* 命令开关初始化 */
    for (i = 1; i < 16; i++)
    {
        SWITCH[i] = 0;
    }
 
    SWITCH[1] = 1;
    SWITCH[6] = 1;
    return head;
}
 
/* 检查学号 */
int CheckID(char* s)
{
    int i;
 
    if (strlen(s) == 0 || strlen(s) > MAXID) return 0;
 
    for (i = 0; i < strlen(s); i++)
    {
        if (s[i] < '0' || s[i] > '9') return 0;
    }
 
    return 1;
}
 
/* 检查姓名 */
int CheckName(char* s)
{
    int i;
 
    if (strlen(s) == 0 || strlen(s) > MAXNAME) return 0;
 
    for (i = 0; i < strlen(s); i++)
    {
        if (!(s[i] >= 'a' && s[i] <= 'z' || s[i] >= 'A' && s[i] <= 'Z')) return 0;
    }
 
    return 1;
}
 
/* 检查分数 */
int CheakScore(int score)
{
    if (score > 100 || score <= 0) return 0;
    return 1;
}
 
/* 检查相同学号 */
int IsSameID(char* s)
{
	Student *p = head->next;
	while(p != NULL)
	{
		if (strcmp(s, p->id) == 0) return 1;
		p = p->next;
	}
	return 0;
}
 
/* 给p指向的节点输入信息 */
void InputNodeInfo(Student* p)
{
    fflush(stdin);
 
    /* 学号 */
    printf("\n请输入学号: ");
    do
    {
        gets(p->id);
 
        if (!CheckID(p->id))
        {
            printf("数据违法，请重新输入学号: ");
		}
		else if (IsSameID(p->id))
		{
			printf("已存在此学号，请重新输入: ");
		}
    }while (!(CheckID(p->id) && !IsSameID(p->id)));
 
    /* 姓名 */
    printf("请输入姓名: ");
    do
    {
        gets(p->name);
 
        if (!CheckName(p->name))
        {
            printf("数据违法，请重新输入姓名: ");
        }
    }
    while (!CheckName(p->name));
 
    /* 成绩 */
    int i;
    for (i = 0; i < CLASS; i++)
    {
        printf("请输入 %s 成绩: ", CLASSNAME[i]);
        do
        {
            fflush(stdin);
            scanf("%d", &p->score[i]);
 
            if (!CheakScore(p->score[i]))
            {
                printf("数据违法，请重新输入 %s 成绩: ", CLASSNAME[i]);
            }
        }
        while (!CheakScore(p->score[i]));
    }
 
    /* 总分及平均分 */
    p->sum = -1;
    p->ave = -1;
}
 
/* 输出p指向节点的信息 */
void OutputNodeInfo(Student* p)
{
    int i;
    printf("\n");
    printf("姓名: %s\n", p->name);
    printf("学号: %s\n", p->id);
 
    for (i = 0; i < CLASS; i++)
    {
        printf("%s 成绩: %d\n", CLASSNAME[i], p->score[i]);
    }
 
    /* 计算过才输出 */
    if (SWITCH[8]) printf("总分: %d\n", p->sum);
    if (SWITCH[8]) printf("平均分: %.2lf\n", p->ave);
}
 
/* 返回r的前一个节点 */
Student* SearchFrontNode(Student* r)
{
    Student *p = head;
    while (p->next != r) p = p->next;
    return p;
}
 
/* 删除r指向的节点 */
void DeleteNode(Student* r)
{
    Student *p = SearchFrontNode(r);
    p->next = r->next;
}
 
/* 头插法插入节点 */
void InsertBefore()
{
    Student *s = MALLOC;
    InputNodeInfo(s);
    s->next = head->next;
    head->next = s;
}
 
/* 输入链表 */
void InputList()
{
    int n;
    printf("有多少个学生信息要输入? ");
    scanf("%d", &n);
 
    while (n--)
    {
        InsertBefore();
    }
}
 
/* 按学号查找 */
Student* SearchID(char* id)
{
    Student *p = head->next;
 
    while (p != NULL)
    {
        if (strcmp(p->id, id) == 0) break;
        p = p->next;
    }
 
    return p;
}
 
/* 按姓名查找 */
Student* SearchName(char* name)
{
    Student *p = head->next;
 
    while (p != NULL)
    {
        if (strcmp(p->name, name) == 0) break;
        p = p->next;
    }
 
    return p;
}
 
/* 按学号或姓名查找删除节点 */
void SearchDeleteNode()
{
    Student *p;
    fflush(stdin);
    char str[20];
    char sure[20];
 
    /* 输入合法性判断 */
    printf("请输入你要删除的学生的 姓名 或 学号: ");
    do
    {
        gets(str);
 
        if (!(CheckID(str) || CheckName(str)))
        {
            printf("数据违法，请重新输入姓名或学号: ");
        }
    }
    while (!(CheckID(str) || CheckName(str)));
 
    /* 判断是姓名还是学号 */
    if (str[0] >= '0' && str[0] <= '9')
    {
        p = SearchID(str);
 
        if (p == NULL)
        {
            printf("对不起，找不到这个学号\n");
        }
        else
        {
        	OutputNodeInfo(p);
        	printf("确认删除? (输入\"y\"确认，任意键取消): ");
        	if (strcmp(gets(sure), "y") == 0)
        	{
	            DeleteNode(p);
	            printf("删除成功\n");
	            SWITCH[6] = 0;
        	}
        	fflush(stdin);
        }
    }
    else
    {
        p = SearchName(str);
 
        if (p == NULL)
        {
            printf("对不起，找不到这个姓名\n");
        }
        else
        {
        	OutputNodeInfo(p);
        	printf("确认删除? (输入\"y\"确认，任意键取消): ");
        	if (strcmp(gets(sure), "y") == 0)
        	{
	            DeleteNode(p);
	            printf("删除成功!\n");
	            SWITCH[6] = 0;
         	}
        	fflush(stdin);
        }
    }
}
 
/* 输出链表 */
void OutList()
{
    Student *p = head->next;
 
    /* 空表处理 */
    if (p == NULL)
    {
        printf("暂无学生信息!\n");
    }
 
    while (p != NULL)
    {
        OutputNodeInfo(p);
        p = p->next;
    }
}
 
/* 按姓名查找记录并打印 */
void SearchPrintNode()
{
    Student *p = head->next;
    int ok = 1; 
    char name[20];
    fflush(stdin);
 
    /* 姓名合法性判断 */
    printf("请输入你要查找的学生姓名: ");
    do
    {
        gets(name);
 
        if (!CheckName(name))
        {
            printf("数据违法，请重新输入姓名: ");
        }
    }
    while (!CheckName(name));
 
    /* 按姓名查找节点 */
    while (p != NULL)
    {
        if (strcmp(p->name, name) == 0)
		{
			ok = 0;
			OutputNodeInfo(p);
		}
        p = p->next;
    }
 
    if (ok)
    {
        printf("对不起，找不到这个姓名\n");
    }
}
 
/* 计算总分和均分 */
void Compute()
{
    int i;
    Student *p = head->next;
 
    while (p != NULL)
    {
        int sum = 0;
 
        for (i = 0; i < CLASS; i++)
        {
            sum += p->score[i];
        }
 
        p->sum = sum;
        p->ave = sum * 1.0 / CLASS;
        p = p->next;
    }
}
 
/* 比较学号 */
int CmpID(Student* a, Student* b, int k)
{
    return strcmp(a->id, b->id);
}
 
/* 比较总分 */
int CmpSum(Student* a, Student* b, int k)
{
    return b->sum - a->sum;
}
 
/* 比较各科分数 */
int CmpScore(Student* a, Student* b, int k)
{
    return b->score[k] - a->score[k];
}
 
/* 选择最大元素 */
Student* SearchMaxNode(int (*cmp)(Student* a, Student* b, int k), int k)
{
    Student *p = head->next;
    Student *max = p;
 
    while (p != NULL)
    {
        if (cmp(p, max, k) < 0)
        {
            max = p;
        }
        p = p->next;
    }
 
    return max;
}
 
/* 排序 */
Student* Sort(int (*cmp)(Student* a, Student* b, int k), int k)
{
    Student *newhead = MALLOC;
    Student *p = newhead;
    Student *max;
 
    while (head->next != NULL)
    {
        max = SearchMaxNode(cmp, k);
        p->next = max;
        DeleteNode(max);
        p = p->next;
    }
 
    /* 表尾处理 */
    p->next = NULL;
    return newhead;
}
 
/* 输出p指向节点的信息到文件 */
void OutputToFile(FILE* fp, Student* p, int newline)
{
    int i;
    fprintf(fp, "%s\n", p->name);
    fprintf(fp, "%s\n", p->id);
 
    for (i = 0; i < CLASS - 1; i++)
    {
        fprintf(fp, "%d\n", p->score[i]);
    }
 
    /* 尾行处理 */
    if (newline)
    {
        fprintf(fp, "%d\n", p->score[i]);
    }
    else
    {
        fprintf(fp, "%d", p->score[i]);
    }
}
 
/* 将s插入链表尾部 */
void InsertAfter(Student* s)
{
    Student *p = head;
 
    while (p->next != NULL) p = p->next;
 
    s->next = NULL;
    p->next = s;
}
 
/* 保存到文件 */
void SaveToFile()
{
	/* 处理追加表尾情况 */
    if (SWITCH[12])
    {
        InsertAfter(tmp);
    }
 
    FILE *fp;
    char file[20];
    fflush(stdin);
    printf("请输入文件名: ");
    gets(file);
 
    if ((fp = fopen(file, "wt+")) == NULL)
    {
        printf("对不起，无法创建文件!\n");
        return;
    }
 
    Student *p = head->next;
 
    while (p != NULL)
    {
        if (p->next != NULL)
        {
            OutputToFile(fp, p, 1);
        }
        else
        {
            OutputToFile(fp, p, 0);
        }
 
        p = p->next;
    }
 
    printf("文件保存成功!\n");
    fclose(fp);
    SWITCH[6] = 1;
 
    /* 处理追加表尾情况 */
    if (SWITCH[12])
    {
        DeleteNode(tmp);
        SWITCH[12] = 0;
    }
}
 
/* 从文件中读入记录 */
void LoadFile()
{
    int i;
    FILE *fp;
    char file[20];
    fflush(stdin);
    printf("请输入文件名: ");
    gets(file);
 
    if ((fp = fopen(file, "rt")) == NULL)
    {
        printf("对不起，无法打开文件!\n");
        return;
    }
 
    /* 文件未结束时读入数据 */
    while (!feof(fp))
    {
        Student *s = MALLOC;
        fscanf(fp, "%s", s->name);
        fscanf(fp, "%s", s->id);
 
        for (i = 0; i < CLASS; i++)
        {
            fscanf(fp, "%d", &s->score[i]);
        }
 
        s->next = head->next;
        head->next = s;
    }
 
    printf("文件读取成功!\n");
    fclose(fp);
}
 
/* 复制文件 */
void CopyFile()
{
    FILE *fp1, *fp2;
    char ch, file1[20], file2[20];
    fflush(stdin);
    /* 读入源文件 */
    printf("请输入源文件名: ");
    gets(file1);
 
    if ((fp1 = fopen(file1, "rb")) == NULL)
    {
        printf("对不起，无法打开文件!\n");
        return;
    }
 
    /* 读入目标文件 */
    printf("请输入目标文件名: ");
    gets(file2);
 
    if ((strcmp(file1, file2) == 0) || ((fp2 = fopen(file2, "wb")) == NULL))
    {
        printf("对不起，无法创建文件!\n");
        return;
    }
 
    /* 逐个字符拷贝 */
    while (!feof(fp1))
    {
        ch = fgetc(fp1);
 
        if (ch != EOF)
            fputc(ch, fp2);
    }
 
    fclose(fp1);
    fclose(fp2);
    printf("文件拷贝成功!\n");
}
 
/* 追加记录到文件中 */
void InsertToFile()
{
    tmp = MALLOC;
    InputNodeInfo(tmp);
    SWITCH[12] = 1;
}
 
/* 分类统计 */
void Stat()
{
    int i, j, n = 0;
    int sum[CLASS] = {0};
    Student *p = head->next;
 
    if (p == NULL)
    {
        printf("暂无学生信息，无法统计\n");
        return;
    }
 
    /* 统计各科总分 */
    while (p != NULL)
    {
        /* 记录学生总数 */
        n++;
 
        for (i = 0; i < CLASS; i++)
        {
            sum[i] += p->score[i];
        }
 
        p = p->next;
    }
 
    /* 各科分别输出 */
    for (i = 0; i < CLASS; i++)
    {
        printf("%s 总均分: %.2lf\n", CLASSNAME[i], sum[i] * 1.0 / n);
        head = Sort(CmpScore, i);
        j = 0;
        p = head->next;
 
        while (p != NULL)
        {
            j++;
            printf("NO.%d %s %d\n", j, p->name, p->score[i]);
            p = p->next;
        }
 
        printf("\n");
    }
}
 
/* 释放链表 */
void FreeList(Student* p)
{
	if (p->next != NULL)
	{
		FreeList(p->next);
	}
	free(p);
}
 
/* 退出 */
void Quit()
{
    if (!SWITCH[6])
    {
        printf("请先保存文件!\n");
        return;
    }
    if (head != NULL)
    {
        FreeList(head);
    }    
    exit(0);
}

#include <stdio.h>
#include <stdlib.h>
 
 
int main()
{
    int i, k, n, m;
    scanf("%d%d", &n, &m);
    for (i = 0; i < m; i++)
    {
        scanf("%d", &k);
        printf("%d/%d\n", n-k+1, n-k+2);
    }
    //system("pause");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
 
int a[100001];
 
int main()
{
    int i, t, n;
    int val;
    scanf("%d", &t);
    while(t--)
    {
        val = 0;
        scanf("%d", &n);
        for (i = 0; i < n; i++)
        {
            scanf("%d", &a[i]);
        }
        for (i = 0; i < n; i++)
        {
            val ^= a[i];
        }
        printf("%d\n", val);
    }
    //system("pause");
    return 0;
}

/*
Slyar
2009.10.29
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
 
#define N 255
#define M 2*N - 1
 
/* 运行成功标记 */
int ok = 0;
 
/* 保存原文件名 */
char file[20] = {};
 
/* 哈夫曼树节点类型 */
typedef struct
{
    int data; /* 字符值 */
    int weight; /* 权重 */
    int parent; /* 双亲结点 */
    int lchild; /* 左孩子结点 */
    int rchild; /* 右孩子结点 */
}Tree;
 
/* 哈夫曼编码类型 */
typedef struct
{
    /* 存放哈夫曼码 */
    char cd[N]; 
    int start;
}Code;
 
/* 生成节点及编码数组 */
Tree ht[M];
Code hcd[N];
 
/* 函数声明 */
int cmp(const void*, const void*);
int NumberOfChar();
void Reset();
void InputFile();
void Encode(int);
void Decode(int);
void OutputFile(int);
void PrintHuffmanCode(int);
void CreateHT(int);
void CreateHCode(int);
 
/* 主函数 */
int main()
{
    int x = 0;
    int n = 0;
    char ch;
    while(1)
    {
        system("cls");
        printf("1. 读入原文件\n");
        printf("2. 在屏幕上打印哈夫曼代码表\n");
        printf("3. 编码原文件\n");
        printf("4. 解码原文件\n");
        printf("5. 退出\n");
        printf("Input 1-5:");
 
        scanf("%d", &x);
 
        switch(x)
        {
            case 1:
                Reset();
                InputFile();
                if (ok)
                {
                    /* 排序使得有效字符在前面 */
                    qsort(ht, N, sizeof(Tree), cmp);
                    /* 记下有效字符的个数 */
                    n = NumberOfChar();
                    CreateHT(n);
                    CreateHCode(n);
                    OutputFile(n);
                    system("pause");
                }
                break;
            case 2:
                system("cls");
                if (ok)
                {
                    PrintHuffmanCode(n);
                }
                else
                {
                    printf("原文件尚未读入!\n");
                }
                system("pause");
                break;
            case 3:
                system("cls");
                if (ok)
                {
                    Encode(n);
                }
                else
                {
                    printf("原文件尚未读入!\n");
                }
                system("pause");
                break;
            case 4:
                system("cls");
                if (ok)
                {
                    Decode(n);
                }
                else
                {
                    printf("原文件尚未读入!\n");
                }
                system("pause");
                break;
            case 5:
                return 0;
            default:
                /* 防止输入错误序号，刷新缓冲区 */
                fflush(stdin);
        }
    }
    return 0;
}
 
/* 快速排序比较函数 */
int cmp(const void *a ,const void *b)
{
    return (*(Tree *)a).weight < (*(Tree *)b).weight ? 1 : -1;
}
 
/* 统计有效的字符数量 */
int NumberOfChar()
{
    int i, num = 0;
    for (i = 0; i < N; i++)
    {
        if (ht[i].weight > 0) num++;
    }
    return num;
}
 
/* 初始化哈夫曼树 */
void Reset()
{
    int i;
    for (i = 0; i < M; i++)
    {
        ht[i].weight = 0;
        ht[i].parent = -1;
        ht[i].lchild = -1;
        ht[i].rchild = -1;
    }
}
 
/* 读入文件内容 */
void InputFile()
{
    FILE *fp;
    char ch;
    system("cls");
    printf("请输入原文件名:");
    fflush(stdin);
    scanf("%s", file);
 
    /* 打开原文件 */
    if ((fp = fopen(file, "rt")) == NULL)
    {
        printf("找不到原文件 %s!\n", file);
        ok = 0;
        system("pause");
        return;
    }
 
    /* 读入字符并处理权重 */
    while (fscanf(fp, "%c", &ch) != EOF)
    {
        ht[ch].data = ch;
        ht[ch].weight++;
    }
 
    /* 关闭文件指针 */
    fclose(fp);
    printf("原文件 %s 读入成功!\n", file);
    ok = 1;
}
 
/* 编码 */
void Encode(int n)
{
    int i, k;
    char ch;
    FILE *fp1, *fp2;
 
    /* 利用哈夫曼代码表进行编码 */
    if (access("Huffman_Code.txt",0) != 0)
    {
        printf("找不到代码表 Huffman_Code.txt !\n");
        return;
    }
 
    /* 打开要编码的原文件 */
    if ((fp1 = fopen(file, "rt")) == NULL)
    {
        printf("找不到原文件 %s !\n", file);
        return;
    }
 
    /* 生成编码文件 */
    if ((fp2 = fopen("Encode.txt", "wt+")) == NULL)
    {
        printf("编码文件 Encode.txt 创建失败!\n");
        return;
    }
 
    /* 一个字符一个字符替换 */
    while (fscanf(fp1, "%c", &ch) != EOF)
    {
        for (i = 0; i < n; i++)
        {
            if (ht[i].data == ch)
            {
                for (k = hcd[i].start; k <= n; k++)
                {
                    fprintf(fp2, "%c", hcd[i].cd[k]);
                }
            }
        }
    }
 
    /* 关闭文件指针 */
    fclose(fp1);
    fclose(fp2);
    printf("编码成功，结果在 Encode.txt 中!\n");
}
 
/* 解码 */
void Decode(int n)
{
    int i, k;
    char ch;
    FILE *fp1, *fp2;
 
    /* 打开要解码的文件 */
    if ((fp1 = fopen("Encode.txt", "rt")) == NULL)
    {
        printf("找不到编码文件 Encode.txt!\n");
        return;
    }
 
    /* 生成解码文件 */
    if ((fp2 = fopen("Decode.txt", "wt+")) == NULL)
    {
        printf("解码文件 Decode.txt 创建失败!\n");
        return;
    }
 
    /* 利用哈夫曼树解码 */
    i = 2 * n - 2;
    while (fscanf(fp1, "%c", &ch) != EOF)
    {
        if (ch == '0')
        {
            i = ht[i].lchild;
        }
        else
        {
            i = ht[i].rchild;
        }
        /* 找到叶子节点为止 */
        if (ht[i].lchild == -1)
        {
            fprintf(fp2, "%c", ht[i].data);
            /* 继续从根节点开始查找 */
            i = 2 * n - 2;
        }
    }
 
    /* 关闭文件指针 */
    fclose(fp1);
    fclose(fp2);
    printf("解码成功，结果在 Decode.txt 中!\n");
}
 
/* 输出哈弗曼编码到文件 */
void OutputFile(int n)
{
    FILE *fp;
    int i, k;
 
    /* 生成哈夫曼代码表文件 */
    if ((fp = fopen("Huffman_Code.txt", "wt+")) == NULL)
    {
        printf("代码表文件 Huffman_Code.txt 创建失败!\n");
        return;
    }
 
    /* 将内存里的东西写入文件 */
    for (i = 0; i < n; i++)
    {
        fprintf(fp, "%d ", ht[i].data);
        for (k = hcd[i].start; k <= n; k++)
        {
            fprintf(fp, "%c", hcd[i].cd[k]);
        }
        if (i < n - 1) fprintf(fp, "\n");
    }
 
    /* 关闭文件指针 */
    fclose(fp);
    printf("代码表文件 Huffman_Code.txt 生成成功!\n");
}
 
/* 打印哈夫曼编码到屏幕 */
void PrintHuffmanCode(int n)
{
    int i, k;
    printf("ASCII \t Char \t HuffmanCode\n");
    for (i = 0; i < n; i++)
    {
        printf("%d \t \"%c\" \t ", ht[i].data, ht[i].data);
        for (k = hcd[i].start; k <= n; k++)
        {
            printf("%c", hcd[i].cd[k]);
        }
        printf("\n");
    }
}
 
/* 构造哈夫曼树 */
void CreateHT(int n)
{
    int i, k ,lmin, rmin;
    int min1, min2;
 
    /* 一共有2n-1个节点 */
    for (i = n; i < 2 * n - 1; i++)
    {
        /*lmin和rmin为最小权重的两个节点置*/
        min1 = min2 = 0x7FFFFFFF;
        lmin = rmin = -1;
        for (k = 0; k <= i - 1; k++)
        {
            /*只在尚未构造二叉树的节点中查找*/
            if (ht[k].parent == -1)
            {
                if (ht[k].weight < min1)
                {
                    min2 = min1;
                    rmin = lmin;
                    min1 = ht[k].weight;
                    lmin = k;
                }
                else if (ht[k].weight < min2)
                {
                    min2 = ht[k].weight;
                    rmin = k;
                }
            }
        }
 
        /* 修改2个小权重节点的双亲 */
        ht[lmin].parent = i;
        ht[rmin].parent = i;
 
        /* 修改双亲的权重 */
        ht[i].weight = ht[lmin].weight + ht[rmin].weight;
 
        /* 修改双亲的孩子 */
        ht[i].lchild = lmin;
        ht[i].rchild = rmin;
    }
}
 
/* 得到哈夫曼编码 */
void CreateHCode(int n)
{
    int i, f, c;
    Code hc;
 
    /* 根据哈夫曼树求哈夫曼编码 */
    for (i = 0; i < n; i++)
    {
        hc.start = n;
        c = i;
        f = ht[i].parent;
 
        /* 循序直到树根结点 */
        while (f != -1)
        {
            /* 处理左孩子结点 */
            if (ht[f].lchild == c)
            {
                hc.cd[hc.start--] = '0';
            }
            /* 处理右孩子结点 */
            else
            {
                hc.cd[hc.start--] = '1';
            }
            c = f;
            f = ht[f].parent;
        }
 
        /* start指向哈夫曼编码最开始字符 */
        hc.start++;
        hcd[i] = hc;
    }
}

#include <iostream>
#define SIZE 1001
 
using namespace std;
 
int main()
{
    int i, j, n, top, temp;
    int stack[SIZE];
    cin >> n;
 
    top = 0;
    /* 第一个元素可能为0 */
    stack[0] = -1;
    for (i = 0; i < n; i++)
    {
        cin >> temp;
        /* 比栈顶元素大数就入栈 */
        if (temp > stack[top])
        {
            stack[++top] = temp;
        }
        else
        {
            int low = 1, high = top;
            int mid;
            /* 二分检索栈中比temp大的第一个数 */
            while(low <= high)
            {
                mid = (low + high) / 2;
                if (temp > stack[mid])
                {
                    low = mid + 1;
                }
                else
                {
                    high = mid - 1;
                }
            }
            /* 用temp替换 */
            stack[low] = temp;
        }
    }
 
    /* 最长序列数就是栈的大小 */
    cout << top << endl;
 
    //system("pause");
    return 0;
}

/*
Slyar
2009.10.31
*/
 
#include <iostream>  
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>
#include <cmath>
 
using namespace std;
 
/* 存放解集 */
vector<string> ivec;
 
/* 第1个数和第2个数的值及表达式 */
double key1_2[6] = {0};
string exp1_2[6];
 
/* 第3个数和第4个数的值及表达式 */
double key3_4[6] = {0};
string exp3_4[6];
 
/* 第3个数和前2个数的值及表达式 */
double key12_3[6] = {0};
string exp12_3[6];
 
/* 第4个数和前3个数的值及表达式 */
double key123_4[6] = {0};
string exp123_4[6];
 
/* 前2个数和后2个数的值及表达式 */
double key12_34[6] = {0};
string exp12_34[6];
 
/* 函数声明 */
int Permutation(int[], int[][4]);
void Calc(double, double, double[], string[], string, string);
void Work(int[], int[][4], int);
 
/* 主函数 */
int main()
{
    int num[4] = {0};
    int array[24][4] = {0};
    int count = 0;
 
    cout << "请输入4个1-13之间的整数，中间以空格隔开" << endl;
 
    /* 读入数据 */
    for (int i = 0; i < 4; i++)
    {
        cin >> num[i];
    }
 
    /* 待检测数据的数量 */
    count = Permutation(num, array);
 
    /* 求解24点 */
    Work(num, array, 24);
 
    /* 对结果进行排序 */
    sort(ivec.begin(), ivec.end());
 
    /* 去掉重复的解 */
    vector<string>::iterator iter = unique(ivec.begin(), ivec.end());
 
    /* 输出解集 */
    if (ivec.size() != 0)
    {
        cout << "该组数据的解集为:" << endl;
        for (vector<string>::iterator it = ivec.begin(); it != iter; it++)
        {
            cout << *it << endl;
        }
    }
    else
    {
        cout << "该组数据无解" << endl;
    }
 
    system("pause");
    return 0;
}
 
/* 计算2个数，保存值及表达式 */
void Calc(double a, double b, double key[], string exp[], string expa, string expb)
{
    key[0] = a + b;
    exp[0] = '(' + expa + '+' + expb + ')';
 
    key[1] = a - b;
    exp[1] = '(' + expa + '-' + expb + ')';
 
    key[2] = b - a;
    exp[2] = '(' + expb + '-' + expa + ')';
 
    key[3] = a * b;
    exp[3] = '(' + expa + '*' + expb + ')';
 
    if (b > 0)
    {
        key[4] = a / b;
        exp[4] = '(' + expa + '/' + expb + ')';
    }
 
    if (a > 0)
    {
        key[5] = b / a;
        exp[5] = '(' + expb + '/' + expa + ')';
    }
}
 
/* 生成数据的排列组合 */
int Permutation(int num[], int array[][4])
{
    int flag;
    int k = 0;
    int count = 0;
    int i, j, m, n, s;
    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 4; j++)
        {
            for (m = 0; m < 4; m++)
            {
                for (n = 0; n < 4; n++)
                {
                    if (i != j && i != m && i != n && j != m && j != n && m != n)
                    {
                        flag = 1;
                        for(s = 0; s < k; s++)
                        {
                            if(array[s][0] == num[i] && array[s][1] == num[j] && array[s][2] == num[m] && array[s][3] == num[n])
                            {
                                flag = 0;
                            }
                        }
                        if (flag == 1)
                        {
                            array[k][0] = num[i];
                            array[k][1] = num[j];
                            array[k][2] = num[m];
                            array[k][3] = num[n];
                            k++;
                            count++;
                        }
                    }
                }
            }
        }
    }
    return count;
}
 
/* 求解24点 */
void Work(int num[], int array[][4], int count)
{
    for (int i = 0; i < count; i++)
    {
        char buffer[20];
        string expa, expb;
 
        /* 转换第1个数字为表达式 */
        itoa(array[i][0], buffer, 10);
        expa = buffer;
 
        /* 转换第2个数字为表达式 */
        itoa(array[i][1], buffer, 10);
        expb = buffer;
 
        /* 计算第1个数和第2个数 */
        Calc(array[i][0], array[i][1], key1_2, exp1_2, expa, expb);
 
        /* (((A,B),C),D)形式 */
        for (int j = 0; j < 6; j++)
        {
            /* 转换第3个数字为表达式 */
            itoa(array[i][2], buffer, 10);
            expb = buffer;
 
            /* 计算第3个数和前2个数 */
            Calc(key1_2[j], array[i][2], key12_3, exp12_3, exp1_2[j], expb);
 
            for (int k = 0; k < 6; k++)
            {
                /* 转换第4个数字为表达式 */
                itoa(array[i][3], buffer, 10);
                expb = buffer;
 
                /* 计算第4个数和前3个数 */
                Calc(key12_3[k], array[i][3], key123_4, exp123_4, exp12_3[k], expb);
 
                for (int t = 0; t < 6; t++)
                {
                    if (fabs(key123_4[t] - 24) < 1e-6)
                    {
                        ivec.push_back(exp123_4[t]);
                    }
                }
            } 
        }
 
        /* 转换第3个数字为表达式 */
        itoa(array[i][2], buffer, 10);
        expa = buffer;
 
        /* 转换第4个数字为表达式 */
        itoa(array[i][3], buffer, 10);
        expb = buffer;
 
        /* 计算第3个数和第4个数 */
        Calc(array[i][2], array[i][3], key3_4, exp3_4, expa, expb);
 
        /* ((A,B),(C,D))形式 */
        for (int j = 0; j < 6; j++)
        {
            for (int k = 0; k < 6; k++)
            {
                /* 计算前2个数和后2个数 */
                Calc(key1_2[j], key3_4[k], key12_34, exp12_34, exp1_2[j], exp3_4[k]);
 
                for (int t = 0; t < 6; t++)
                {
                    if (fabs(key12_34[t] - 24) < 1e-6)
                    {
                        ivec.push_back(exp12_34[t]);
                    }
                }
            }
        }
    }
}

#include <iostream>
 
using namespace std;
 
/* 构造完成标志 */
bool sign = false;
 
/* 创建数独矩阵 */
int num[9][9];
 
/* 函数声明 */
void Input();
void Output();
bool Check(int n, int key);
int DFS(int n);
 
/* 主函数 */
int main()
{
    cout << "请输入一个9*9的数独矩阵，空位以0表示:" << endl;
    Input();
    DFS(0);
    Output();
    system("pause");
}
 
/* 读入数独矩阵 */
void Input()
{
    char temp[9][9];
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        {
            cin >> temp[i][j];
            num[i][j] = temp[i][j] - '0';
        }
    }
}
 
/* 输出数独矩阵 */
void Output()
{
    cout << endl;
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        {
            cout << num[i][j] << " ";
            if (j % 3 == 2)
            {
                cout << "   ";
            }
        }
        cout << endl;
        if (i % 3 == 2)
        {
            cout << endl;
        }
    }
}
 
/* 判断key填入n时是否满足条件 */
bool Check(int n, int key)
{
    /* 判断n所在横列是否合法 */
    for (int i = 0; i < 9; i++)
    {
        /* j为n竖坐标 */
        int j = n / 9;
        if (num[j][i] == key) return false;
    }
 
    /* 判断n所在竖列是否合法 */
    for (int i = 0; i < 9; i++)
    {
        /* j为n横坐标 */
        int j = n % 9;
        if (num[i][j] == key) return false;
    }
 
    /* x为n所在的小九宫格左顶点竖坐标 */
    int x = n / 9 / 3 * 3;
 
    /* y为n所在的小九宫格左顶点横坐标 */
    int y = n % 9 / 3 * 3;
 
    /* 判断n所在的小九宫格是否合法 */
    for (int i = x; i < x + 3; i++)
    {
        for (int j = y; j < y + 3; j++)
        {
            if (num[i][j] == key) return false;
        }
    }
 
    /* 全部合法，返回正确 */
    return true;
}
 
/* 深搜构造数独 */
int DFS(int n)
{
    /* 所有的都符合，退出递归 */
    if (n > 80)
    {
        sign = true;
        return 0;
    }
    /* 当前位不为空时跳过 */
    if (num[n/9][n%9] != 0)
    {
        DFS(n+1);
    }
    else
    {
        /* 否则对当前位进行枚举测试 */
        for (int i = 1; i <= 9; i++)
        {
            /* 满足条件时填入数字 */
            if (Check(n, i) == true)
            {
                num[n/9][n%9] = i;
                /* 继续搜索 */
                DFS(n+1);
                /* 返回时如果构造成功，则直接退出 */
                if (sign == true) return 0;
                /* 如果构造不成功，还原当前位 */
                num[n/9][n%9] = 0;
            }
        }
    }
}

#include <iostream>
#include <string>
 
using namespace std;
 
const int MAX = 20;
 
/* 定义矩阵的长和宽 */
int width, height;
 
/* 定义矩阵 */
char map[MAX][MAX];
 
/* 定义标记矩阵 */
bool ext[MAX][MAX];
 
/* 定义方向数组 */
int dir[8][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}, {1,1}, {-1,-1}, {1,-1}, {-1,1}};
 
/* 定义当前符合字符的个数 */
int step;
 
/* 函数声明 */
void Input(); 
void Output();
void Dfs(string, int, int, int);
void FindWords(string);
 
/* 主函数 */
int main()
{
    cin >> height >> width; 
 
    Input();
 
    int n;
    cin >> n;
    while (n--)
    {
        string str;
        cin >> str;
        FindWords(str);
    }
    cout << endl;
 
    Output();
 
    system("pause");
}
 
/* 读入矩阵函数 */
void Input()
{
    int i, j;
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            cin >> map[i][j];
        }
        cin.get();
    }
}
 
/* 输出矩阵函数 */
void Output()
{
    int i, j;
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            if (ext[i][j] == true)
            {
                cout << map[i][j] << " ";
            }
            else
            {
                cout << "  ";
            }
        }
        cout << endl;
    }    
}
 
/* Dfs搜索单词 */
void Dfs(string str, int i, int j, int k)
{
    /* 符合字符数+1 */
    step++;
    /* 找到单词就退出递归 */
    if (step == str.size())
    {
        /* 标记找到单词 */
        ext[i][j] = true;
        return;
    }
    int x, y;
    /* 向一个方向一直找下去 */
    x = i + dir[k][0];
    y = j + dir[k][1];
    /* 如果字符相同则继续递归搜索(注意要防止数组下标越界) */
    if (x >= 0 && x < width && y >= 0 && y < height && map[x][y] == str[step])
    {
        Dfs(str, x, y, k);
        /* 标记找到单词 */
        if (step == str.size()) ext[i][j] = true;
    }
}
 
/* 找出单词 */
void FindWords(string str)
{
    int i, j;
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            /* 如果首字符相同才搜索 */
            if (map[i][j] == str[0])
            {
                int k;
                /* 分别向八个方向搜索 */
                for (k = 0; k < 8; k++)
                {
                    step = 0;
                    Dfs(str, i, j, k);
                    /* 找到单词就立刻返回 */
                    if (step == str.size()) return;
                }
            }
        }
    }
}

/* father[x]表示x的父节点 */
int father[MAX];
/* rank[x]表示x的秩 */
int rank[MAX];

/* 初始化集合 */
void Make_Set(int x)
{
	father[x] = x;
	rank[x] = 0;
}

/* 查找x元素所在的集合,回溯时压缩路径 */
int Find_Set(int x)
{
	if (x != father[x])
	{
		father[x] = Find_Set(father[x]);
	}
	return father[x];
}

/* 按秩合并x,y所在的集合 */
void Union(int x, int y)
{
	x = Find_Set(x);
	y = Find_Set(y);
	if (x == y) return;
	if (rank[x] > rank[y])
	{
		father[y] = x;
	}
	else
	{
		if (rank[x] == rank[y])
		{
			rank[y]++;
		}
		father[x] = y;
	}
}

#include <stdio.h>
#include <stdlib.h>
 
#define MAX 100
#define MAXCOST 0x7fffffff
 
int graph[MAX][MAX];
 
int Prim(int graph[][MAX], int n)
{
	/* lowcost[i]记录以i为终点的边的最小权值，当lowcost[i]=0时表示终点i加入生成树 */
	int lowcost[MAX];
 
	/* mst[i]记录对应lowcost[i]的起点，当mst[i]=0时表示起点i加入生成树 */
	int mst[MAX];
 
	int i, j, min, minid, sum = 0;
 
	/* 默认选择1号节点加入生成树，从2号节点开始初始化 */
	for (i = 2; i <= n; i++)
	{
		/* 最短距离初始化为其他节点到1号节点的距离 */
		lowcost[i] = graph[1][i];
 
		/* 标记所有节点的起点皆为默认的1号节点 */
		mst[i] = 1;
	}
 
	/* 标记1号节点加入生成树 */
	mst[1] = 0;
 
	/* n个节点至少需要n-1条边构成最小生成树 */
	for (i = 2; i <= n; i++)
	{
		min = MAXCOST;
		minid = 0;
 
		/* 找满足条件的最小权值边的节点minid */
		for (j = 2; j <= n; j++)
		{
			/* 边权值较小且不在生成树中 */
			if (lowcost[j] < min && lowcost[j] != 0)
			{
				min = lowcost[j];
				minid = j;
			}
		}
		/* 输出生成树边的信息:起点，终点，权值 */
		printf("%c - %c : %d\n", mst[minid] + 'A' - 1, minid + 'A' - 1, min);
 
		/* 累加权值 */
		sum += min;
 
		/* 标记节点minid加入生成树 */
		lowcost[minid] = 0;
 
		/* 更新当前节点minid到其他节点的权值 */
		for (j = 2; j <= n; j++)
		{
			/* 发现更小的权值 */
			if (graph[minid][j] < lowcost[j])
			{
				/* 更新权值信息 */
				lowcost[j] = graph[minid][j];
 
				/* 更新最小权值边的起点 */
				mst[j] = minid;
			}
		}
	}
	/* 返回最小权值和 */
	return sum;
}
 
int main()
{
	int i, j, k, m, n;
	int x, y, cost;
	char chx, chy;
 
	/* 读取节点和边的数目 */
	scanf("%d%d", &m, &n);
	getchar();
 
	/* 初始化图，所有节点间距离为无穷大 */
	for (i = 1; i <= m; i++)
	{
		for (j = 1; j <= m; j++)
		{
			graph[i][j] = MAXCOST;
		}
	}
 
	/* 读取边信息 */
	for (k = 0; k < n; k++)
	{
		scanf("%c %c %d", &chx, &chy, &cost);
		getchar();
		i = chx - 'A' + 1;
		j = chy - 'A' + 1;
		graph[i][j] = cost;
		graph[j][i] = cost;
	}
 
	/* 求解最小生成树 */
	cost = Prim(graph, m);
 
	/* 输出最小权值和 */
	printf("Total:%d\n", cost);
 
	//system("pause");
	return 0;	
}