邀风醉明月

双指针，二分，模拟，贪心经典题目

1244 Estrella’s Chocolate

题目描述
Estrella是个漂亮的小姑娘，她最喜欢吃的零食就是巧克力，但是巧克力吃多了会发胖，美貌和美食之间她必须做出艰难地选择。
Estrella有N颗巧克力，她按照喜欢的程序给巧克力排好序，并决定在M天内吃完这些巧克力。由于一颗巧克力如果不一次吃完，味道就会变坏，所以她绝对不会把一颗巧克力分开吃。但是每颗巧克力的热量并不相同，Estralla希望知道M天中每天吃的巧克力热量总和最大值。为了尽可能防止发胖，她希望这个值越小越好，请问这个值最小是多少？

输入
第一行是一个整数T(1≤T≤100)，表示样例的个数。
每个样例的第一行是两个整数N,M(1≤M≤N≤10000)。
每个样例的第二行是N个整数，表示每颗巧克力的热量，其值处于[1,100000] 之间。

输出
每行输出一个样例的结果。

样例输入
2
5 2
5 3 2 4 1
5 3
5 3 2 4 1
样例输出
8
5

import java.io.*;

public class Main {
    static int n,m,day;
    public static void main(String[] args) throws IOException {
        StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int t=(int)in.nval;
        while(t-->0) {
        	in.nextToken();
        	int n=(int)in.nval;
        	in.nextToken();
        	int m=(int)in.nval;
        	int a[]=new int [n];
        	int l=0,r=0;
        	for(int i=0;i<n;i++) {
        		in.nextToken();
        		a[i]=(int)in.nval;
        		r+=a[i];
        	//	l=Math.max(l, a[i]);
        	}
        	while(l<=r) {//左闭右闭
        		int day=1;
        		int sum=0;
        		int mid=(l+r)/2;
        		for(int i=0;i<n;i++) {
        			if(sum+a[i]<=mid) {
        				sum+=a[i];
        			}
        			else {
        				day++;
        				sum=a[i];
        			}
        		}
        		if(day>m) {
        			l=mid+1;
        		}
        		else {
        			r=mid-1;
        		}
     		
        		
        	}
        	pw.println(l);
        	pw.flush();   
        	/*
        	 * 得想想要输出的是什么
        	 */
        }
        
    }

}

1262 Fish

钓鱼
题目描述
小明很喜欢钓鱼，现在有n个池塘可以钓鱼，第i个池塘首次内能钓到ai条鱼。第i个池塘如果被钓过k次，那么每次下一次能钓到的鱼的数目为max{0,ai−k×bi}。现在小明能钓m次鱼，请问他最多能钓到多少条鱼？

输入
第一行是一个整数T(1≤T≤100)，表示样例的个数。
每个样例的第一行是n(1≤n≤1000),m(1≤m≤100000)；
以后的n行，每行是ai(1≤ai≤10000),bi(0≤bi≤10000)。

输出
每行输出一个样例的结果。

样例输入
2
3 5
3 1
4 2
1 0
2 5
2 1
1 1
样例输出
12
4
样例解释
第一个样例，在第1个池塘钓3次，第2个池塘钓2次，3+2+1+4+2 = 12；
第二个样例，在第1个池塘钓2次，第2个池塘钓1次，2+1+1 = 4。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

public class Main {
    
    static class Node{
        int a;
        int b;
    }
    
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int t=(int)in.nval;
        while(t!=0) {
            Queue<Node> queue = new PriorityQueue<>(new Comparator<Node>() {

                @Override
                public int compare(Node o1, Node o2) {
                    // TODO Auto-generated method stub
                    return o2.a-o1.a;
                }

            });
            
            
            in.nextToken();
            int n=(int)in.nval;
            in.nextToken();
            int m=(int)in.nval;
            //Node node=new Node();每次存进queue的都是同一个node地址
            for(int i=0;i<n;i++) {
                Node node=new Node();//这里node每次循环都是新的，
                in.nextToken();
                node.a=(int)in.nval;
                
                in.nextToken();
                node.b=(int)in.nval;
                queue.add(node);//存进去的是node的地址。
            }
            
            int ans=0;
            while(!queue.isEmpty()) {
                Node no =queue.poll();
                if(no.b==0) {
                    ans+=no.a*m;
                    break;
                }
                else if(no.a==0){
                    break;
                }
                else {
                    ans+=no.a;
                    no.a=Math.max(0,no.a-no.b);
                    queue.add(no);
                    m--;
                }
                if(m==0) {
                    break;
                }

            }
            pw.println(ans);
            pw.flush();
            t--;
        }
        
    

    }
}

1269 Craftman

Craftsman
题目描述
Alice是游戏中的一名工匠，游戏中最近“恶魔手套”很热，她准备做一批，正好可以赚一笔。制作一件“恶魔手套”需要n种原材料，第i种原料需要ai份，Alice已经有第i种原料bi份。 Alice还有k份兑换券，兑换券可以去商店兑换任意的原料，但一份兑换券只能兑换一份。请问Alice最多可以制作多少件“恶魔手套”。

输入
第一行是一个整数T(1≤T≤100)，表示样例的个数。
每个样例的第一行是n(1≤n≤1000),k(0≤k≤109)，第二行是ai(1≤ai≤109)，第三行是bi(0≤bi≤109)。

输出
每行输出一个样例的结果。

样例输入
4
1 1000000000
1
1000000000
1 1
3
1
3 1
1 2 3
3 5 9
3 2
1 2 3
3 5 8
样例输出
2000000000
0
3
3

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {
	static long k;
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int t=(int)in.nval;
		while(t-->0) {
			in.nextToken();
			int n=(int)in.nval;
			in.nextToken();
			k=(long)in.nval;
			long a[]=new long [n];
			long b[]=new long [n];
			for(int i=0;i<n;i++) {
				in.nextToken();
				a[i]=(long)in.nval;

				
			}
			for(int i=0;i<n;i++) {
				in.nextToken();
				b[i]=(long)in.nval;
			}
			long l=0,r=(long) (2e9+5);
			/*
			 * 注意int与long的区别，防止溢出
			 * 
			 */
			while(l<=r) {//尽量写成左闭右闭
				long mid=(l+r)/2;
				if(f(k,mid,a,b))
					l=mid+1;
				else r=mid-1;
				
			}
			if(!f(k,l,a,b))l--;
			pw.println(l);
			pw.flush();
		}
	}
	static boolean f(long s,long x,long a[],long b[]) {
	//	long s=k;//直接对全局变量进行运算就会导致全局变量的改变,间接就不会
		for(int i=0;i<a.length;i++) {
			s-=Math.max(0, a[i]*x-b[i]);
			if(s<0)return false;
		}
		return true;
	}

}

1275 Exam Schedule

题目描述
Eric每次考试最头痛的就是安排考试时间，需要找合适的空闲时间安排考试真的是件很费神的事情。
Eric希望你能帮他算一下能哪些时间可以考试，当然Eric并不想周末进行考试，所以你只需要计算周1到周5的时间就可以了。我们假设每天有11节课的时间，上午1到4节，下午5-8节，晚上9-11节。Eric已经拿到了参加考试的班级的课表，以及考试需要的时长。注意：考试只能安排在上午、下午、晚上时段，不能跨区间。

输入
第一行是一个整数K(1≤K≤100)，表示样例的个数
每个样例的第一行是两个整数N(1≤N≤100),T(2≤T≤4)，分别表示这些班级课表的条目数和考试所需的课程节数。为了简化问题，Eric只留下了课表条目的上课时间。
以后的N行，每行一个课程的时间，为三个值，D(D∈{Mon,Tue,Wen,Thur,Fri,Sat,Sun}),S,E(1≤S≤E≤11)，分别表示上课时间为星期D的第S节到第E节。

输出
每个样例先输出一行，为每个样例合适考试的不同时间段的个数。然后按时间先后顺序，每行输出一个时间段，分别为S,D,E，中间用一个空格隔开。

样例输入
1
10 3
Mon 1 2
Tue 1 2
Wen 1 2
Thur 1 2
Fri 1 2
Mon 5 6
Tue 5 6
Wen 5 6
Thur 5 6
Fri 5 6
样例输出
5
Mon 9 11
Tue 9 11
Wen 9 11
Thur 9 11
Fri 9 11

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {
    static int k,n,t,s,e;
    static String st;
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        k=(int)in.nval;
        while(k!=0) {
            in.nextToken();
            n=(int)in.nval;
            in.nextToken();
            t=(int)in.nval;
            int [][] a=new int [6][12];
            for(int i=0;i<n;i++) {
                in.nextToken();
                st=in.sval;
                in.nextToken();
                s=(int)in.nval;
                in.nextToken();
                e=(int)in.nval;
                if(st.equals("Mon")) {
                    for(int j=s;j<=e;j++) {
                        a[1][j]=1;
                    }
                }
                else if(st.equals("Tue")) {
                    for(int j=s;j<=e;j++) {
                        a[2][j]=1;
                    }
                }
                else if(st.equals("Wen")) {
                    for(int j=s;j<=e;j++) {
                        a[3][j]=1;
                    }
                }
                else if(st.equals("Thur")) {
                    for(int j=s;j<=e;j++) {
                        a[4][j]=1;
                    }
                }
                else if(st.equals("Fri")) {
                    for(int j=s;j<=e;j++) {
                        a[5][j]=1;
                    }
                }
            }
            int ans=0;
            int[][] aa=new int [1000][2];
            for(int i=1;i<=5;i++) {
                int tmp=0;
                for(int j=1;j<=4;j++) {
                    if(a[i][j]==0) {
                        tmp++;
                        if(tmp>=t) {
                            aa[ans][0]=i;
                            aa[ans++][1]=j-t+1;
                        }
                    }
                    else {
                        tmp=0;
                    }
                }
                tmp=0;
                for(int j=5;j<=8;j++) {
                    if(a[i][j]==0) {
                        tmp++;
                        if(tmp>=t) {
                            aa[ans][0]=i;
                            aa[ans++][1]=j-t+1;
                        }
                    }
                    else {
                        tmp=0;
                    }
                }
                tmp=0;
                for(int j=9;j<=11;j++) {
                    if(a[i][j]==0) {
                        tmp++;
                        if(tmp>=t) {
                            aa[ans][0]=i;
                            aa[ans++][1]=j-t+1;
                        }
                    }
                    else {
                        tmp=0;
                    }
                }
            }
            pw.println(ans);
            pw.flush();
            for(int i=0;i<ans;i++) {
                if(aa[i][0]==1) {
                    pw.println("Mon "+aa[i][1]+" "+(aa[i][1]+t-1));
                    pw.flush();
                }
                else if(aa[i][0]==2) {
                    pw.println("Tue "+aa[i][1]+" "+(aa[i][1]+t-1));
                    pw.flush();
                }
                else if(aa[i][0]==3) {
                    pw.println("Wen "+aa[i][1]+" "+(aa[i][1]+t-1));
                    pw.flush();
                }
                else if(aa[i][0]==4) {
                    pw.println("Thur "+aa[i][1]+" "+(aa[i][1]+t-1));
                    pw.flush();
                }
                else if(aa[i][0]==5) {
                    pw.println("Fri "+aa[i][1]+" "+(aa[i][1]+t-1));
                    pw.flush();
                }
            }
            k--;
        }
    }

}

1287 银行

Bank
题目描述
银行使用取号系统来排队提供服务，假设只有一个服务窗口。用户从s时刻开始取号，业务需要办理t时间，如果在等待d分钟之后仍然没有轮到该用户办理，用户就会走掉。用户分为两种，一种是普通客户，一种是VIP客户。 VIP客户的优先级高于普通客户，如果同时有多位客户在等待，优先VIP客户。同类客户按取号的时间顺序先到先服务。不考虑叫号的等待时间，请计算出每个客户的等待时长。

输入
只有一个样例。
每行一个用户的信息，包括用户ID，取号时刻s，办理时长t，最长等待时间d，用户数不超过200人次。
用户ID首字母是由一个字母和四位数字组成，第一个字母如果是大写字母N，表示用户是普通客户，第一个字母是大写字母V，表示用户是VIP客户。
时刻使用"HH24:MM"格式，办理时长和等待时长单位为分钟
输入数据保证所有取号时间都唯一，且按取号时间升序排列，所有的业务在当天办理完成。

输出
按客户的取号时间顺序，输出用户ID和等待时长（时长使用分钟为单位），是否办理业务，如果成功办理，输出Yes，否则输出No

样例输入
N0001 09:00 5 3
N0002 09:01 10 4
V0001 09:02 5 5
N0003 09:03 5 12
V0002 09:04 5 6
样例输出
N0001 0 Yes
N0002 4 No
V0001 3 Yes
N0003 12 Yes
V0002 6 Yes

import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {
	static int t;
	static Node first=new Node();
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
		Queue<Node>  nnode=new LinkedList<Node>();
		Queue<Node>  vnode=new LinkedList<Node>();//注意这里很离谱		
		Queue<Node>  out=new LinkedList<Node>();
		
		int a[]=new int [250];
		int x=0;
		while(in.hasNext()) {
			Node node =new Node();
			node.st=in.next();
			node.hhmm=in.next();//别用in.nextLine()
			for(int i=0;i<5;i++) {
				if(i==0)
				node.m=(node.hhmm.charAt(i)-'0')*10*60;
				else if(i==1) {
					node.m+=(node.hhmm.charAt(i)-'0')*60;
				}
				else if(i==3) {
					node.m+=(node.hhmm.charAt(i)-'0')*10;
				}
				else if(i==4) {
					node.m+=(node.hhmm.charAt(i)-'0');
				}
			}
			a[x++]=node.m;
			
			node.t=in.nextInt();
			node.d=in.nextInt();
			if(node.st.charAt(0)=='N') {
				nnode.add(node);
			}
			else{
				vnode.add(node);
			}
			
		}
		boolean flag;
		if(!vnode.isEmpty()&&!nnode.isEmpty()&&nnode.peek().m<vnode.peek().m) {//
			first=nnode.poll();
		}
		else if(!vnode.isEmpty()&&!nnode.isEmpty()&&nnode.peek().m>=vnode.peek().m) {
			first=vnode.poll();
		}
		else if(!nnode.isEmpty()){
			first=nnode.poll();

		}
		else if(!vnode.isEmpty()) {
			first=vnode.poll();
		}
		
		int time=first.m;
		int yn=0;
		while(!nnode.isEmpty()||!vnode.isEmpty()) {
			if(first.m!=-1) {

					Node zan=new Node();
					zan.st=first.st;
					zan.wait=0;
					zan.yes="Yes";
					zan.m=first.m;
					out.add(zan);
					time+=first.t;
				
				first.m=-1;
			}
			else if(first.m==-1) {
				if(!nnode.isEmpty()&&!vnode.isEmpty()) {
					Node nn=(vnode.peek().m<=time)?vnode.poll():nnode.poll();//改为time
					yn=nn.m+nn.d;
					if(yn>=time) {
						Node zan=new Node();
						zan.st=nn.st;
						
						if(time-nn.m<0) {
							time=nn.m+nn.t;
							zan.wait=0;
						}
						else {
							zan.wait=time-nn.m;							
							time+=nn.t;

						}
						zan.yes="Yes";
						zan.m=nn.m;
						out.add(zan);
						
					}
					else {
						Node zan=new Node();
						zan.st=nn.st;
						zan.wait=nn.d;
						zan.yes="No";
						zan.m=nn.m;
						out.add(zan);

				
					}
				}
				else if(!nnode.isEmpty()) {
					Node nn=nnode.poll();
					yn=nn.m+nn.d;
					if(yn>=time) {
						Node zan=new Node();
						zan.st=nn.st;
						if(time-nn.m<0) {
							time=nn.m+nn.t;
							zan.wait=0;
						}
						else {
							zan.wait=time-nn.m;							
							time+=nn.t;

						}
						zan.yes="Yes";
						zan.m=nn.m;
						out.add(zan);
					}
					else {
						Node zan=new Node();
						zan.st=nn.st;
						zan.wait=nn.d;
						zan.yes="No";
						zan.m=nn.m;
						out.add(zan);
				
					}					
				}
				else if(!vnode.isEmpty()) {
					Node nn=vnode.poll();
					yn=nn.m+nn.d;
					if(yn>=time) {
						Node zan=new Node();
						zan.st=nn.st;
						if(time-nn.m<0) {
							time=nn.m+nn.t;
							zan.wait=0;
						}
						else {
							zan.wait=time-nn.m;							
							time+=nn.t;

						}
						zan.yes="Yes";
						zan.m=nn.m;
						out.add(zan);
					}
					else {
						Node zan=new Node();
						zan.st=nn.st;
						zan.wait=nn.d;
						zan.m=nn.m;
						zan.yes="No";
						out.add(zan);
					}					
				}
			}
		}
		for(int i=0;i<x;i++) {
			for(Node g:out) {
				if(g.m==a[i]) {
					pw.println(g.st+" "+g.wait+" "+g.yes);
					pw.flush();
				}
			}
		}

		
	}
	static class Node{
		String st;
		String hhmm;
		int m;
		int t;
		int d;
		int wait;
		String yes;
	}
}

1305 斐波那契区间

题目描述
一个数列a1,a2,⋯,an，如果对于区间[L,R],1≤L≤R≤n,∀i(L≤i≤R−2),ai+2=ai+1+ai，那么我们称其为斐波那契区间。求数列中最长的斐波那契区间长度。

输入
第一行是一个整数T(1≤T≤1000)，表示样例的个数。
每个样例有两行，第一行是数列的元素个数n(2≤n≤10000)。
第二行是n个整数ai(0≤ai≤109)。

输出
每行输出一个样例的结果。

样例输入
2
10
1 2 3 5 8 13 21 34 55 89
5
1 1 1 1 1
样例输出
10
2

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int t=(int)in.nval;
        while(t!=0) {
            in.nextToken();
            int n=(int)in.nval;
            long []a=new long[n];
            for(int i=0;i<n;i++) {
                in.nextToken();
                a[i]=(long)in.nval;
            }
            int ans=2;
            int tem=2;
            for(int i=2;i<n;i++) {//双指针太复杂了。还是单指针好用
                if(a[i]==a[i-1]+a[i-2]) {
                    tem++;
                    ans=Math.max(ans,tem);
                }
                else {
                    tem=2;
                }

                    
                
            }
            pw.println(ans);
            pw.flush();
            t--;
        }
    }
    
}

#include
int max(int a,int b)
{
    return a>b ? a : b;
} 

int main()
{
    int k;
    scanf("%d",&k);
    while(k--)
    {
        int n;
        int a[10001];
        scanf("%d",&n);
        for(int i=1; i<=n; i++)
            scanf("%d",&a[i]);
        
        int ans=2;
        int l=1,r=3;
        while(l<=n&&r<=n)
        {
            if(a[r]==a[r-1]+a[r-2])
            {
                ans=max(ans,r-l+1);
                r++;
            }
            else
            {
                
                l=r-1;
                r++;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

1344 最长连续子串

最长连续子串
题目描述
给一个字符串s=“a1a2a3…an”，如果存在区间[L,R],L≤i

输入
存在多个输入样例，每个样例占一行，为一个长度不超过1000的，只含小写英文的字符串。

输出
每行依次输出每个样例的结果。

样例输入
abc
ababbac
a

样例输出
3
2
1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        Scanner in=new Scanner(System.in);
        StreamTokenizer hh =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
        while(in.hasNext()) {
            String a=in.next();
            int ans=1;
            int tem=1;
            for(int i=1;i<a.length();i++) {//双指针太复杂了。还是单指针好用
                if(a.charAt(i)==a.charAt(i-1)+1) {
                    tem++;
                    ans=Math.max(ans,tem);
                }
                else {
                    tem=1;
                }

                    
                
            }
            pw.println(ans);
            pw.flush();
        }
    }
    
}

1348 数字

数字
题目描述
正整数n和k，你每一步，按下列规则执行

如果n的尾部为数码0，就去掉尾部的数码0，直到尾部数码不为0。
否则，将 n = n - k
不断迭代，直到 n < k 。

求一共需要迭代多少步及最后的n值。

输入
第一行是一个整数T(1≤T≤1000)，表示样例的个数。以后每行一个样例，为两个整数n(1≤n≤109),k(1≤k≤104)

输出
每行输出一个样例的结果，包括两个整数，即步数和最后的n值。

样例输入
4
112 3
203 3
333 3
1000000000 2
样例输出
5 1
2 2
5 0
1 1
样例解释
第1个样例： 112→109→106→103→100→1。
第2个样例： 203→200→2。
第3个样例： 333→330→33→30→3→0。
第4个样例： 1000000000→1。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {
	static long [] a=new long [10];
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int t=(int)in.nval;
		while(t!=0) {
			long ans=0;
			in.nextToken();
			long n=(long)in.nval;
			in.nextToken();
			long k=(long)in.nval;
			for(int i=1;i<=9;i++) {
				a[i]=k*i%10;
			}
			while(n>=k) {
				if(n%10==0) {
					while(n%10==0) {
						n=n/10;
					}
					ans++;
				}
				else {
					int flag=0;
					for(int i=1;i<10;i++) {
						if(n%10==a[i]) {
							
							if(n>k*i) {//得加上正数的限制条件
								n-=k*i;
								ans+=i;
								flag=1;
								break;
							}
							else {
								ans+=n/k;
								n=n%k;
								break;
							}
							
							
							
						}
					}
					if(flag==0) {
						ans+=n/k;//
						n=n%k;
					}
				}
				
			}
			pw.println(ans+" "+n);
			pw.flush();			
			t--;
		}
	}

}

1368 substring

题目描述
一个字符串s=a1a2…an,其子串为s′=aiai+1…ak,1≤i≤k≤n。我们相求其最短的子串的长度，子串中含所有26个英文字母。

输入
存在多组样例，样例数不超过1000个。
每行输入一行字符串，长度不超过2000个字符，且只含小写英文字母。

输出
每行输出一个样例的结果。如果不存在这样的子串，输出0。

样例输入
abcdefghijklmnopqrstuvwxyz
abacadaeafagahaiajakalamanaoapaqarasatauavawaxayaz
abcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxy
样例输出
26
49
0

import java.util.HashSet;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Scanner in=new Scanner(System.in);
			while(in.hasNext()) {
				String st=in.next();
				int ans=100000;
				int[] a=new int [26];
				HashSet<Character>set=new HashSet<>();
				for(int i=0;i<st.length();i++) {
					a[st.charAt(i)-'a']=i;					
					if(set.size()!=26) {
						set.add(st.charAt(i));

					}
					if(set.size()==26){//注意两个if
						int max=0,min=100000;
						for(int j=0;j<26;j++) {
							max=Math.max(max, a[j]);
							min=Math.min(min, a[j]);
						}
						ans=Math.min(max-min+1, ans);
					}
					
				}
				if(set.size()<26) {
					ans=0;
				}
				System.out.println(ans);
			}
	}
}

1381 表格

表格
题目描述
用户输入一个表格的文本，请按如下格式输出：

用’-‘表示横线，’|‘表示竖线，’+'表示横竖线的交点
列宽为当前列最长字符串长度+2
每列的对齐方式相同，一共有三种，分别为靠左对齐，居中对齐，靠右对齐，分别用’l’,‘c’,'r’表示。
a. 靠左对齐，字符串左端距离边线1个空格；
b. 居中对齐，字符串距离边线左和右空格数的差不超过1，且左边空格数小于等于右边空格数。
c. 靠右对齐，字符串右端距离边线1个空格；
输入
第一行是一个整数T(1≤T≤100) ，表示样例的个数。

每个样例的第1行是两个整数r,c(1≤r,c≤10)，表示表格的行和列数。
第2行是c个字符，字符只由’l’,‘c’,'r’三种组成，依次表示对应列的对齐方式。
以后的r行，每行c个字符串，表示对应行列的单元格内容，字符串只含英文字母，数字，长度不超过20个字符。

输出
按格式依次输出每个样例的的结果。

样例输入
1
3 5
lcccr
Name English Math Chinese Total
Alice 100 85 75 260
Bob 85 100 85 270
样例输出
±------±--------±-----±--------±------+
| Name | English | Math | Chinese | Total |
±------±--------±-----±--------±------+
| Alice | 100 | 85 | 75 | 260 |
±------±--------±-----±--------±------+
| Bob | 85 | 100 | 85 | 270 |
±------±--------±-----±--------±------+

1382 正方形

由火柴棍组成的一个n×n的正方形，按从上到下，从左到右的顺序给火柴棍编号，从1开始，比如下图中，一共有24根火柴棍。问去掉若干个火柴棍之后，这个图形中还存在多少个正方形？

如下图所示，n=3时，去掉12,17,23号火柴棒之后，还剩下5个正方形。

输入
第一行是一个整数T(1≤T≤1000)，表示样例的个数。

每个样例的第1行是两个整数n(1≤n≤50)，表示图形的宽度。样例的第2行首先是一个整数m(0≤m≤2n(n+1)，表示去掉火柴棍的个数，后面接m个整数，表示去掉火柴棍的序号，所有序号都是唯一的。

输出
依次，每行输出一个样例的结果

样例输入
2
3
0
3
3 12 17 23
样例输出
14
5

1388 积木

题目描述
积木块都是相同的立方体，一共有n列积木堆，这n列积木排成一排，每堆上是ai个积木堆叠起来，并且保证从左到右，每列的积木数是非递减的。

现在你还有k个积木块，请把这k个积木块放到积木上（可以只用部分积木块，但不能堆新的列）。你想的到一个连续的积木列，并使得这些积木列具有相同的高度。

请问你能得到这样的积木列的最大宽度？

输入格式
第一行是一个整数T (1≤T≤100)，表示样例的个数。每个样例的第一行是两个整数n (1≤n≤10000), k (1≤k≤109)。第二行是n个正整数ai,1≤ai≤105，表示n列。

输出格式
依次输出每个样例的结果，为一个整数。

样例输入
3
5 0
1 1 2 2 3
5 1
1 1 2 2 3
5 2
1 1 2 2 3
样例输出
2
3
4
样例解释
第一个样例，不能放任何积木块，所以连续同高积木列的宽度为2。
第二个样例，我们可以在第2列上放一个积木块，这样我们得到宽度为3的高度为2的连续同高积木列。
第三个样例，我们可以在第1,2列上各放一个积木块，这样我们得到宽度为4的高度为2的连续同高积木列。

提示
巨大的输入量，请使用stdio.h头文件，并使用C风格的输入。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int t=(int)in.nval;
		while(t!=0) {
			in.nextToken();
			int n=(int)in.nval;
			in.nextToken();
			long k=(long)in.nval;
			int a[]=new int [n];
			for(int i=0;i<n;i++) {
				in.nextToken();
				a[i]=(int)in.nval;
			}
			int ans=1;
			int l=0,r=1,sum=0;
			while(l<n&r<n) {
				if(a[r]!=a[r-1]) {
					sum+=(r-l)*(a[r]-a[r-1]);
				}
				if(sum<=k) {
					ans=Math.max(ans, r-l+1);
					
					
				}		
				while(sum>k) {
					sum-=(a[r]-a[l]);
					l++;
					
				}
		
				r++;
			}

			pw.println(ans);
			pw.flush();
			t--;
		}
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int t=(int)in.nval;
		while(t!=0) {
			in.nextToken();
			int n=(int)in.nval;
			in.nextToken();
			long k=(long)in.nval;
			int a[]=new int [n];
			for(int i=0;i<n;i++) {
				in.nextToken();
				a[i]=(int)in.nval;
			}
			int ans=1,i=0,size=1,kk=0;
			for(int j=1;j<n;j++) {//其实也是双指针的方法
				size++;				
				if(a[j]!=a[j-1]) {
					kk=kk+(j-i)*(a[j]-a[j-1]);
				}

				while(kk>k) {
					kk=kk-(a[j]-a[i]);
					i++;
					size--;
				}
				if(ans<size) {
					ans=size;
				}
			}
			pw.println(ans);
			pw.flush();
			t--;
		}
	}

}

1407 Alice and Bob

题目描述
Alice和Bob打球，已知他们打过的每一回合的输赢情况，每个回合获胜的一方可以得一分。 Alice可以随意设定赢得一局比赛所需的分数和赢得整个比赛所需要的局数。 Alice想赢得比赛，请问在满足下列条件下，Alice应该怎么设置这两个参数，保证自己能赢？

所有的回合都必须用来计算比赛的结果，即每一局比赛都会完整的结束，不会存在未完成的对局
谁先拿到赢得一局所需的分数就赢得这一局
谁先达到赢得比赛所需的局数就赢得这场比赛
不会出现某一方已经赢得比赛的一局或者整场比赛后，还继续打球的情况
每局胜利所需要的分数是相同
输入
包含不超过1000组样例，每个样例为一行。每行输入一个只含字母’W’和’L’的字符串，长度不超过200，'W’和’L’分别表示这一回合Alice赢或者输。

输出
每个样例先输出一行，为合法方案的总数。然后按局分，局数的升序，每一行输出一个方案，包括两个整数，即局分和局数。如果Alice无法赢或者没有合法的方案，只需要输出方案数为0即可。

样例输入
LWW
WLWW
LLWW
样例输出
2
1 2
2 1
2
1 3
3 1
0
样例解释
第一个样例：可以每局先得1分者胜，先赢得2局的人获得整场胜利；也可以每局先得2分者胜，先赢得1局的人获得整场胜利。第二个样例：可以每局先得3分者胜，先赢得1局的人获得整场胜利；也可以每局先得1分者胜，先赢得3局的人获得整场胜利。不能令每局先得2分者胜，先赢得1局的人获得整场胜利，因为那样会留下未完成的对局。第三个样例：可怜的Alice无论如何也不能赢。

第一个样例的第一种情况是：bob先拿到了1分，赢了一局，之后alice拿到了2分，赢了2局，则取得了比赛的胜利。
第二种情况是：bob先拿到了1分，之后，alice拿到了2分，赢了1局，取得了胜利

1408 Cow

题目描述
农夫约翰有一个农场，他把上面分成了n×m个格子，每个格子里养了一头牛。但是有p对相邻格子（有共同边的格子）的牛是敌对关系，喜欢打架，约翰想做一些栅栏把他们分开。所有的栅栏都是沿着边线的，横的或者竖的，每条栅栏都是贯穿整个横边或者竖边的。但是约翰的预算有限，他想知道最多建k条栅栏使得尽可能减少打架的牛的对数。比如下图中，相同的字符表示会相互打架的牛，我们可以建3条栅栏（红线），使得所有敌对关系的牛都隔离开。

cow

输入
第一行是一个整数T(1≤T≤400)，表示样例的个数。每个样例的第一行是4个整数n(1≤n≤100),m(1≤m≤100),p(1≤p≤2nm−n−m),k(1≤k≤max(1,n+m−2))。以后的p行，每行4个整数x1,y1,x2,y2(1≤x1,x2≤m;1≤y1,y2≤n)，表示(x1,y1)与(x2,y2)的牛需要分开。输入保证没有重复信息并且输入的都是相邻格。

输出
每行输出一个样例的结果，输出在建立k条栅栏的情况下，还会打架的牛的对数。如果可以完全分隔开牛，那么还需要输出需要建立的最少的栅栏数。

样例输入
2
5 5 3 4
1 2 2 2
2 3 3 3
2 4 2 5

5 5 3 1
1 2 2 2
2 3 3 3
2 4 2 5
样例输出
0 3
2
样例解释
输入的样例即图示，明显第一个样例中只需要3条栅栏就能把所有敌对的牛分开；第二个样例只能分开1对牛，所以还剩2对敌对关系的牛。

提示
巨大的输入量，请使用C风格的输入。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.*;
public class Main {

	/*
	 * 
	 * runtime error大概率是数组越界问题
	 * 遇到runtime error时，把一部分代码注释掉，提交通对比法，比较得出哪一部分出了问题。
	 */
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int t=(int)in.nval;
		while(t!=0) {

			in.nextToken();
			int n=(int)in.nval;
			in.nextToken();
			int m=(int)in.nval;
			in.nextToken();
			int p=(int)in.nval;
			in.nextToken();
			int k=(int)in.nval;
			int [] row=new int [105];
			int [] col=new int [105];
			for(int i=0;i<p;i++) {
					in.nextToken();
					int x1=(int)in.nval;
					in.nextToken();
					int y1=(int )in.nval;
					in.nextToken();
					int x2=(int)in.nval;
					in.nextToken();
					int y2=(int)in.nval;
					
					if(x1==x2) {//同一行
						if(y1<y2) {
							col[y1]++;
						}
						else {
							col[y2]++;
						}
					}
					else if(y1==y2) {
						if(x1<x2) {
							row[x1]++;
						}
						else {
							row[x2]++;
						}
					}
			}//前面没问题的
			int shanlan=0;
			int index=0;
			int []buff=new int [200];

			for(int i=0;i<105;i++) {//这里也要由n改成105，才ac。为了确保正确，数组尽量开大点
				if(row[i]!=0) {
					shanlan++;
					buff[index++]=row[i];
				}
			}
			for(int i=0;i<105;i++) {//这里也要由m改成105
				if(col[i]!=0) {
					shanlan++;
					buff[index++]=col[i];			
				}

			}
	        int lanzhu=0;
	        Arrays.sort(buff);
	        for(int i=0;i<k;i++) {
	        	lanzhu+=buff[199-i];//输入的k比buff的最大下标要大，就导致wa
	        }
			if(shanlan<=k) {
				pw.println("0 "+shanlan);
				pw.flush();
			}
			else {
				pw.println(p-lanzhu);
				pw.flush();
			}
			t--;
		}
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.*;

public class Main {

	/*
	 * 
	 * runtime error大概率是数组越界问题
	 * 遇到runtime error时，把一部分代码注释掉，提交通对比法，比较得出哪一部分出了问题。
	 */

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int t=(int)in.nval;
		while(t!=0) {

			in.nextToken();
			int n=(int)in.nval;
			in.nextToken();
			int m=(int)in.nval;
			in.nextToken();
			int p=(int)in.nval;
			in.nextToken();
			int k=(int)in.nval;
			int [] row=new int [105];
			int [] col=new int [105];
			for(int i=0;i<p;i++) {
					in.nextToken();
					int x1=(int)in.nval;
					in.nextToken();
					int y1=(int )in.nval;
					in.nextToken();
					int x2=(int)in.nval;
					in.nextToken();
					int y2=(int)in.nval;
					
					if(x1==x2) {//同一行
						if(y1<y2) {
							col[y1]++;
						}
						else {
							col[y2]++;
						}
					}
					else if(y1==y2) {
						if(x1<x2) {
							row[x1]++;
						}
						else {
							row[x2]++;
						}
					}
			}//前面没问题的
			int shanlan=0;
			int index=0;
			Integer []buff=new Integer[200];//数组空间大小问题。大小要比k大
			for(int i=0;i<200;i++) {
				buff[i]=0;
			}
			for(int i=0;i<105;i++) {//这里也要由n改成105，才ac。为了确保正确，数组尽量开大点
				if(row[i]!=0) {
					shanlan++;
					buff[index++]=row[i];
				}
			}
			for(int i=0;i<105;i++) {//这里也要由m改成105
				if(col[i]!=0) {
					shanlan++;
					buff[index++]=col[i];			
				}

			}
	        int lanzhu=0;
	        Arrays.sort(buff,Collections.reverseOrder());
	        for(int i=0;i<k;i++) {
	        	lanzhu+=buff[i];//输入的k比buff的最大下标要大，就导致wa
	        }
			if(shanlan<=k) {
				pw.println("0 "+shanlan);
				pw.flush();
			}
			else {
				pw.println(p-lanzhu);
				pw.flush();
			}
			t--;
		}
	}

}

1414 累加和

累加和
题目描述
一个整数数列A={a1,a2,…,an}和k次查询，每次查询值s，求存在多少个区间[L,R],1≤L≤R≤n，使得s=∑Ri=Lai。

输入
第一行是一个整数T(1≤T≤10)，表示样例的个数。每个样例的第一行是两个整数n(1≤n≤10000),k(1≤k≤100)。每个样例的第二行是n个正整数ai(1≤ai≤10000)。每个样例的第三行是k个整数，表示k次查询的s值。

输出
每行输出一次查询的结果。

样例输入
2
10 3
1 2 3 1 2 3 1 2 3 4
3 7 9
10 3
1 2 3 4 5 6 7 8 9 10
3 7 9
样例输出
6
3
5
2
2
3

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {
	public static void main(String[] args) throws IOException {
		StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		int t=(int)in.nval;
		while(t--!=0) {
			in.nextToken();
			int n=(int)in.nval;
			in.nextToken();
			int k=(int)in.nval;
			int []a=new int[n];
		    for(int i=0;i<n;i++) {
		    	in.nextToken();
		    	a[i]=(int)in.nval;
		    }
		    while(k--!=0) {
		    	in.nextToken();
		    	int num=(int)in.nval;
		    	int l=0;int r=0;
		    	int sum=0;
		    	int ans=0;
		    	while(r<a.length) {
		    		while(r<a.length&&sum<num) {
		    		sum+=a[r++];
		    		}
		    		if(sum==num) {
		    			ans++;
		    			sum-=a[l++];
		    		}
		    		while(l<r&&sum>num) {
		    			sum-=a[l++];
		    		}
		    		if(sum==num) {
		    			ans++;
		    			sum-=a[l++];
		    		}
		    	}
		    	pw.println(ans);
		    	pw.flush();
		    	
		    }
		}

	}

}

1417 String II

String II
题目描述
一个只含小写英文字母的字符串，每次操作选两种字符，把这两种字符合并成其中一种，每次操作的代价是合并字符个数的平方，请问将字符串变成同一种字符的最小代价？

输入
存在多个输入样例。每行一个字符串，只含小写英文，长度不超过2000。

输出
每行输出一个样例的结果。

样例输入
aab
abc
aaa
abcd
样例输出
9
13
0
24
样例解释
第一个样例，将a和b合并，代价为3²=9；第二个样例，先将a和b合并成a，再将a和c合并成a，代价为2²+3²=13；第三个样例无需合并，代价为0。第四个样例，先将a和b合并成a，再将c和d合并成c，最后将a和c合并成a，代价为2²+2²+4²=24

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
        Scanner in=new Scanner(System.in);
        while(in.hasNext()) {
        	String st=in.next();
        	int a[]=new int [26];
        	for(int i=0;i<st.length();i++) {
        		a[st.charAt(i)-'a']++;
        	}
        	Queue <Integer>queue=new PriorityQueue<>();
        	int flag=0;
        	for(int i=0;i<26;i++) {
        		if(a[i]!=0) {
        			queue.add(a[i]);
        			flag++;
        		}
        	}
        	
        	long ans=0;
        	while(!queue.isEmpty()) {
        		int x=queue.poll();
        		int y=0;
        		if(!queue.isEmpty()) {
        			y=queue.poll();
        		}
        		else {
        			break;
        		}
        		ans+=(x+y)*(x+y);
        		queue.add(x+y);
        	}
        	if(flag==1) {
        		pw.println(0);
        		pw.flush();
        	}
        	else {
        		pw.println(ans);
        		pw.flush();
        	}
        }
	}

}

1419 Balls

题目描述
你有若干个彩球排成一列，你可以交换相邻的两个球。交换后，如果出现包含被交换彩球且长度大于等于3的连续相同颜色彩球，那么这些彩球就会消失，右边的彩球会向左边靠拢填满空间。现在给你一个操作的序列，请依次输出每次操作后的彩球序列。

输入
第一行是一个整数T(1≤T≤100)，表示样例的个数。每个样例包含两行，第一行是一个字符串，长度不超过30，只含大写字母’A’-‘C’，表示不同字母表示不同颜色的球。第二行开始是一个整数n(1≤n≤10),表示操作的个数，以后n个整数ai表示将ai和ai+1交换。输入数据保证是合法的操作。

输出
每个样例的每行输出一个操作后彩球的状况，如果所有的彩球都消失，输出”Over”。每个样例最后输出一个空行。

样例输入
4
AABABBB
1 3
AAAABBBBC
2 4 4
AAAAAA
1 2
AABAABBB
2 3 1
样例输出
Over

AAABABBBC
C

Over

BABBB
A

1423 三角形

题目描述
我们知道三角形必须满足任意两边之和大于第三边，任意两边之差小于第三边。现在有一个边长的多值集E={e1,e2,…,en}，任取三条边，能组成三角形的方案数。

输入
第一行是一个整数T(1≤T≤100)，表示样例的个数。

每个样例的第一行是一个整数n(3≤n≤1000)，表示边集的大小。每个样例的第二行是n个正整数ei,1≤ei≤109，表示边长。

输出
每行输出一个样例的结果。

样例输入
3
5
1 2 3 4 5
5
1 1 1 1 1
5
9 1 1 5 3
样例输出
3
10
0

1427 Range

题目描述
一个多值集A={a1,a2,…,an},如果∀x∈A ,满足 x≤c⋅min(A), c是一个大于1的整数常量,min(⋅)表示求多值集的最小值,那么我们称这个集合是“好”的。现在给你一个多值集，请问最少去掉几个元素，使得多值集是好的？

输入
第一行是一个整数T(1≤T≤100)，表示样例的个数。每个样例的第一行是两个整数n(1≤n≤10000),c(2≤c≤10)，分别表示多值集的大小和常数c；第二行为n个整数ai(1≤ai≤109)。

输出
每行输出一个样例的结果。

样例输入
2
6 2
3 5 4 7 8 3
4 4
1 2 3 4
样例输出
2
0
样例解释
第一个样例，可以去掉两个3，剩下5,4,7,8；或者去掉7和8，剩下3,5,4,3。第二个样例，不用去掉任何一个元素就满足条件。

提示
巨大的输入数据，请使用C风格的输入。

1432 Cycle

题目描述
数字 1∼n顺时钟排成一个圈，从1开始顺时钟计数，数到的数退出这个圈，然后从下一个数字开始数，直到剩下最后一个数字。计数的序列为{a1,a2,…,an−1}, 其中 ai=(a_i−1+a_i−2)%n+1,i>2 且 1≤a1,a2≤n。

比如n=5，计数序列的前两项为{1,2}时，整个计数序列为{1,2,4,2}，那么第一次去掉数字1，得到数字圈为{2,3,4,5}；再从2开始，数两个数，到数字3，去掉得到数字圈为{4,5,2}；依次，再数4个数，到数字4,去掉得到数字圈为{5,2}；最后数2个数，去掉2,剩下5。

请你写个程序，在已知n,a1,a2的情况下，求最后剩下的数？

输入
第一行是一个整数T(1≤T≤1000)，表示样例的个数。

以后每行一个样例，为三个整数n(2≤n≤1000),a1,a2(1≤a1,a2≤n)。

输出
每行输出一个样例的结果。

样例输入
2
3 2 3
5 2 3
样例输出
1
4

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
        StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw =new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int t=(int)in.nval;
        while(t!=0) {
        	t--;
        	in.nextToken();
        	int n=(int)in.nval;
        	int a[]=new int[1005];//如果n==2时，a最大只有1，会造成a[2]的 runtime error
        	int flag[]=new int [n+5];
        	in.nextToken();
        	a[1]=(int)in.nval;
        	in.nextToken();
        	a[2]=(int)in.nval;
        	
        	
        	if(n>2) {
        		for(int i=3;i<=n-1;i++) {//标记
        			a[i]=(a[i-1]+a[i-2])%n+1;
        		}        		
        	}else {
        		if(a[1]==1) {
        			pw.println(2);
        			pw.flush();
        			continue;
        		}
        		else {
        			pw.println(1);
        			pw.flush();
        			continue;
        		}
        	}

        	int j=1;
        	for(int i=1;i<=n-1;i++) {
        		int pos=0;
        		a[i]=a[i]%(n-i+1);//对剩余元素进行取模，不用绕那么多圈
        		if(a[i]==0) {
        			a[i]=n-i+1;
        		}
        		while(a[i]>pos) {
        			if(flag[j]==0) {
        				pos++;
        			}
        			if(j==n) {
        				j=1;
        			}
        			else {
        				j++;
        			}
        		}
        		if(j==1)
        			flag[n]=1;
        		else {
        			flag[--j]=1;
        			j++;
        		}
        	}
        	for(int i=1;i<n+1;i++) {
        		if(flag[i]==0) {
        			pw.println(i);
        			pw.flush();
        			break;
        		}
        	}
        }
	}

}

你可能感兴趣的:(湘潭大学C语言程序设计作业,贪心算法,算法,java)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
想家爆米花机
也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
山东大学小树林支教调研团青青仓木队——翟晓楠山东大学青青仓木队
过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
121. 买卖股票的最佳时机薄荷糖的味道_fb40
给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
教育用心灵温暖心灵
@陈春丽长期学习班冯倩。今天一早就听到说高职合并，取消中专教育的教育信息。感觉是虽然知道，再听还是吓一跳。国家重视职业教育为何还要取消中专技术学校的教育？再听高中就要进行技术教育了，一部分人学习好继续努力学习考大学，一部分人在高中就可以进行职业教育接受职业教育了还要中专技术教育学校干什么呢！a有些职业教育学校转型升级快，不是孩子上完给找工作，而是学校帮孩子创业，我觉得是不错的方向！新闻新你得实时更
2019-01-19 王小康KK
姓名:王康公司:扬州市方圆建筑工程有限公司2018年3月16日～3月18日上海361期《六项精进》感谢二组学员【日精进打卡第307天】【知～学习】《六项精进》大纲3遍共862遍《大学》通篇3遍共860遍《六项精进》全书40页【经典名句】思想决定行为，行为决定习惯，习惯决定性格，性格决定命运。【行～实践】一、修身：（对自己个人）1、践行六项精进的理念。二、齐家：（对家庭和家人）1、和女朋友视频聊天。
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
苦，是因为爱上了某样东西阿梅心理咨询师
佛法里面一直强调，“我执”，苦，是因为陷入了“我执”，我喜欢某样东西，陷入了求不得之苦，我不喜欢我的长相，外貌，身材，因为我想要更美，陷入了“我不美”的执念。我想要考个好成绩，因为我想要进入某所大学，所以开始焦虑。我想要找个男朋友，想要拥有一段美丽的爱情，所以陷入了“情执”。这些想，都是因为求不得。求不得，所以苦。因为爱之切，所以陷入僵局。其实这些念，佛家讲都是虚妄的。可是好多人不自知。依旧寻寻觅
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
童年那些故事教给我们的山川大地日月星辰
同事的女儿二次考研失败，但是仍不气馁还想接着再学再考，得为孩子点个赞，可是同事很矛盾，以她的意见，当初女儿大学毕业就该直接考编，回到家过安稳日子，我问她还记不记得《小马过河》的故事？她说跟小马有啥关系？幼儿园就给孩子讲《小马过河》，当然孩子们除了喜欢故事里的“人物”小松鼠、老牛、小马跟老马，对小马爱劳动喜欢帮助妈妈干活也是有基本认知的，孩子们对为什么老牛说水浅、而松鼠说水深也有一定的常识，到了成人
rust的指针作为函数返回值是直接传递，还是先销毁后创建？ wudixiaotie 返回值
这是我自己想到的问题，结果去知呼提问，还没等别人回答，我自己就想到方法实验了。。 fn main() { let mut a = 34; println!("a's addr:{:p}", &a); let p = &mut a; println!("p's addr:{:p}", &a
java编程思想 -- 数据的初始化百合不是茶 java 数据的初始化
1.使用构造器确保数据初始化 /* *在ReckInitDemo类中创建Reck的对象 */ public class ReckInitDemo { public static void main(String[] args) { //创建Reck对象 new Reck(); } }
[航天与宇宙]为什么发射和回收航天器有档期 comsci
地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁... 所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行 &
linux下批量替换文件内容商人shang linux 替换
1、网络上现成的资料　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 　　linux sed 批量替换多个文件中的字符串　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir` 　　例如：替换/home下所有文件中的www.admi
网页在线天气预报 oloz 天气预报
网页在线调用天气预报 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
SpringMVC和Struts2比较杨白白 springMVC
1. 入口 spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。参见：http://blog.csdn.net/zs15932616453/article/details/8832343 2
refuse copy, lazy girl! 小桔子 copy
妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到： 1.那是我自己觉得写不出的高度 2.如果直接拿来用，很快就能解决问题 3.然后就是抄咩~~ 4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！
apache与php整合 aichenglong php apache web
一 apache web服务器 1 apeche web服务器的安装 1)下载Apache web服务器 2)配置域名(如果需要使用要在DNS上注册) 3)测试安装访问http://localhost/验证是否安装成功 2 apache管理 1)service.msc进行图形化管理 2)命令管理，配
Maven常用内置变量 AILIKES maven
Built-in properties ${basedir} represents the directory containing pom.xml ${version} equivalent to ${project.version} (deprecated: ${pom.version}) Pom/Project properties Al
java的类和对象百合不是茶 JAVA面向对象类对象
java中的类： java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决 java使用 class 类名来创建类，在Java中类名要求和构造方法，Java的文件名是一样的创建一个A类： class A{ } java中的类：将某两个事物有联系的属性包装在一个类中，再通
JS控制页面输入框为只读 bijian1013 JavaScript
在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。
AngularJS与服务器交互 bijian1013 JavaScript AngularJS $http
对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下： var xmlhttp = new XMLHttpRequest(); xmlhttp.onreadystatechange
[Maven学习笔记八]Maven常用插件应用 bit1129 maven
常用插件及其用法位于：http://maven.apache.org/plugins/ 1. Jetty server plugin 2. Dependency copy plugin 3. Surefire Test plugin 4. Uber jar plugin 1. Jetty Pl
【Hive六】Hive用户自定义函数(UDF) bit1129 自定义函数
1. 什么是Hive UDF Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括：文件格式：Text File，Sequence File 内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text 用户提供的 map/reduce 脚本：不管什么
杀掉nginx进程后丢失nginx.pid，如何重新启动nginx ronin47 nginx 重启 pid丢失
nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
UI设计中我们为什么需要设计动效 brotherlamp UI ui教程 ui视频 ui资料 ui自学
随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。一、加强体验舒适度嗯，就是让用户更加爽更加爽的用你的产品。
Spring中JdbcDaoSupport的DataSource注入问题 bylijinnan java spring
参考以下两篇文章： http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/ http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration Sprin
数据库连接池的工作原理 chicony 数据库连接池
随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
java 关键字 CrazyMizzz java
关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。 Java中的关键字按功能主要可以分为以下几类：（1）访问修饰符 public,private,protected p
Hive中的排序语法 daizj 排序 hive order by DISTRIBUTE BY sort by
Hive中的排序语法 2014.06.22 ORDER BY hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
单态设计模式 dcj3sjt126com 设计模式
单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。 <?phpclass Example{ // 保存类实例在此属性中 private static&
svn locked dcj3sjt126com Lock
post-commit hook failed (exit code 1) with output: svn: E155004: Working copy 'D:\xx\xxx' locked svn: E200031: sqlite: attempt to write a readonly database svn: E200031: sqlite: attempt to write a
ARM寄存器学习 e200702084 数据结构 C++c C#F#
无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。 ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。 1、不分组寄存器（R0-R7）不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
常用编码资料 gengzg 编码
List<UserInfo> list=GetUserS.GetUserList(11); String json=JSON.toJSONString(list); HashMap<Object,Object> hs=new HashMap<Object, Object>(); for(int i=0;i<10;i++) {
进程 vs. 线程 hongtoushizi 线程 linux 进程
我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。如果用多线程实现
Linux定时Job：crontab -e 与 /etc/crontab 的区别 Josh_Persistence linux crontab
一、linux中的crotab中的指定的时间只有5个部分：* * * * * 分别表示：分钟，小时，日，月，星期，具体说来：第一段代表分钟 0—59 第二段代表小时 0—23 第三段代表日期 1—31 第四段代表月份 1—12 第五段代表星期几，0代表星期日 0—6 如： */1 * * * * 每分钟执行一次。 *
KMP算法详解 hm4123660 数据结构 C++算法字符串 KMP
字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。假设主串s="ababcabcacbab",模式串为t="
枚举类型的单例模式 zhb8015 单例模式
E.编写一个包含单个元素的枚举类型[极推荐]。代码如下： public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
Kafka+Storm+HDFS ssydxa219 storm
cd /myhome/usr/stormbin/storm nimbus &bin/storm supervisor &bin/storm ui &Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
Java获取本地服务器的IP 中华好儿孙 java Web 获取服务器ip地址
System.out.println("getRequestURL:"+request.getRequestURL()); System.out.println("getLocalAddr:"+request.getLocalAddr()); System.out.println("getLocalPort:&quo

双指针，二分，模拟，贪心经典题目

目录

1244 Estrella’s Chocolate

1262 Fish

1269 Craftman

1275 Exam Schedule

1287 银行

1305 斐波那契区间

1344 最长连续子串

1348 数字

1368 substring

1381 表格

1382 正方形

1388 积木

1407 Alice and Bob

1408 Cow

1414 累加和

1417 String II

1419 Balls

1423 三角形

1427 Range

1432 Cycle

你可能感兴趣的:(湘潭大学C语言程序设计作业,贪心算法,算法,java)