skillart的专栏

#include #include int main() { int n,m; std::cin>>n; while(n--) { std::cin>>m; long double t = m*log10(m*1.0); t -= (__int64)t; __int64 ans =

这是第一次用java搞acm，第一次提交时CE。后来才知道类名必须是Main，果断AC。另外发现数组调用的equals（）是Object里面未经改写的方法，比较的是引用。ps：一个简单的dfs。import java.util.Arrays;import java.util.Scanner;public class Main{ private static char

import java.math.BigInteger;import java.util.Scanner;public class Main{ static BigInteger fac(BigInteger n) { BigInteger result=BigInteger.ONE; for(BigInteger i=BigInteger.ONE;!i.equals(n.add

import java.util.Scanner;public class Main{ public static void main(String args[]) { Scanner cin=new Scanner(System.in); int n; while(cin.hasNextInt()) {

import java.util.Scanner;public class Main{ private static char ch[]; private static int num; private static void slen(char ch[]) { int len=1; for(int i=1;i<=ch.lengt

用数组模拟栈操作可以获得比较短的代码。import java.util.Scanner;public class Main{ public static void main(String args[]) { int n; Scanner cin=new Scanner(System.in); String io[],o1,o2; while(cin.hasNext())

import java.util.Scanner;public class Main{ public static void main(String args[]) { Scanner cin=new Scanner(System.in); int temp=0,result=0; while(cin.hasNext())

第三届国信蓝点杯的一个编程题就是此题的升级版。之前在王晓东的书上看过递归的算法。母函数解法：母函数import java.util.Scanner;public class Main{ public static void main(String args[]) { Scanner cin=new Scanner(System.in);

此题未用到生成字典数，主要有数学知识得到。8个数第一个数字改变一次就是5040次，因此要从高位开始。解题思路：阶乘（索引已经加1）int f[9]={0,1,1,2,6,24,120,720,5040};判断一下M中包含f[8]，f[7]，f[6]。。。f[1]的个数。比如n=11    m=900。                                   m=0*f[8]+1

C语言版#includeint f(int n){ long fn[10000]={0}; int i,j; fn[0]=fn[1]=1; for(i=2;i<=n;i++) { for(j=1;j<=fn[0];j++) fn[j]*=i; for(j=1;j<=fn[0];j++) { if(fn[j]>=10000) { fn[j+1]

00的产生必然由n-1组的01产生，即00的个数等于n-1组01的个数。n-1组01的产生有两个来源。1).由n-2组的1变幻而来2).由n-2组的00变幻1010，其中一个00只能变幻一个01.可以推出第n组00的个数b[n]=b[n-2]+第n-2组1的个数(2^(n-3));import java.math.*;import java.util.*;public cl

#include#include#includechar* reverse(char *str){ int length=strlen(str); int temp,i; for(i=0;i<length/2;i++) { temp=str[i]; str[i]=str[length-i-1]; str[len

题意：For any two numbers i and j you are to determine the maximum cycle length over all numbers between i and j.import java.util.Scanner;public class Main { static int len; static void three(in

题目真不好理解。知道A是右转，V是左转就够了。用java写了个一直PE。只好转成C了。dir用来记录东南西北四个方向，初始向西。#include#includeint main(){ char str[201]; int i,x,y,dir,t; while(~scanf("%s",str)) { x=310,y=420,dir

#include int main() { int i,n,sum,h,m,s,flag,t; char str[500]; float d; scanf("%d%f",&n,&d); while(~scanf("%d",&t)) { flag=1,sum=0; for(i=0;i<n&&flag;i++

用java写老是格式错误，悲剧。只好C了。简单就不多说了。#include#includeint main(){ int n,m,k,i,j,step,t,flag; int coor[20][20]; char ch[20][20]; while(scanf("%d%d%d",&n,&m,&k)!=EOF) { if(n+m+k==0)return 0; for(

这题其实比较水的。但是没有看见最后还要输入end，一直WA。还以为又是java没用好，用c写了个。#include #include int main(){ char str[32767]; int flag,sum,len,i,a[32767]; while(scanf("%s",str),strcmp("end",str)) { flag=1;sum=0; for(

import java.util.*;public class Main { public static void main(String args[]) { Scanner cin=new Scanner(System.in); int t=cin.nextInt(); while(t>0) { int n=cin.nextInt(); int a[]=

import java.util.Scanner;public class Main { public static void main(String args[]) { Scanner cin=new Scanner(System.in); int i=0; while(cin.hasNext()) {

import java.util.Scanner;public class Main { public static void main(String args[]) { Scanner cin=new Scanner(System.in); int a[]=new int[3]; int temp=0; b

画张大图就好了。第n行的第一个正三角数（n-1）^2+1  最后一个正三角数n^2。所以一个数n所在的行是sqrt（n-1）+1。import java.util.Scanner;public class Main { public static void main(String args[]) { int n,m; Scanner cin=new Scanner(S

和8皇后很类似。算法思路：深搜先列后行，如果当前位置不能放置，则转到下一行。当行达到n时，比较得到最大值max。import java.util.Scanner;public class Main{ static int max=0,sum=0; static boolean place(char a[][],int r,int c)//当前位置是否能够放置 {

最小生成树。import java.util.Arrays;import java.util.Scanner;public class Main { static void prim(int n,int adj[][]) { int sum=0; int lowcost[]=new int[n+1]; boolean s[]=new boolean[n+1

import java.util.*;public class Main { static int max,sum; static int h[][]=new int[1002][1002]; //static int a[][]=new int[1002][1002];//这个打算打表优化的，AC了就没用上。 static void dfs(int h[][],

最小生成树。import java.util.Arrays;import java.util.Scanner;public class Main { static int prim(int n,int [][]adj) { int sum=0; int lowcost[]=new int[n+1]; boolean s[]=new boolean[n+1]

建立一个双向的图，从出发点遍历一遍用数组存储上一个顶点即可。import java.util.*;public class Main { static List list; static Map> map; static void store(int a,int b) { list=map.get(a); if(list==null) list=new Ar

相信很多人都是以这道题作为线段树入门吧。推荐一篇博客：写的很清晰：线段树基础遗憾没有找到用java的大牛，直接就把大神的模板转成java了。import java.util.Scanner;public class Main{ static int maxn = 222222; static int MAX[]=new int[maxn<<2];

把字符串反转，然后用反串和原串求最大公共子序列（LCS），再用字符串长度减去LCS的长度就是答案。写的有点废，不过方便以后直接调用。 import java.util.Scanner;public class Main { static int lcs(String str1,String str2) { int len1=str1.length(); in

经典的八数码问题。因为题目

写了太多的dfs，明天就要考试了，写个bfs。好久没有写bfs，有些细节都不熟悉了。本题的意思就是在8X8的棋盘，马走日。其实就是迷宫的变形。不难。import java.util.LinkedList;import java.util.Queue;import java.util.Scanner;class Point{ int x, y; int step;

一直以为是右边的和第一个比，测试数据也正确却一直WA，无语。贪心，扫描标记下。import java.util.Arrays;import java.util.Scanner;class Stick implements Comparable{ public int length; public int weight; public Stic

高有3种，长比 宽长，于是每种矩形可以产生3种类型。对矩形长款降序排序，就转换为最长递减序列问题了。可以用dp   O(n^2)，也可以用dp+二分查找，就是二分查找是在不好写啊。数据比较少，直接dp吧。import java.util.Arrays;import java.util.Scanner;class rectangle implements Comparable

第二个if和第一个顺序不能颠倒，应为sum置0了（可能max0，得到的结果就错了），其实多设置一个temp变量就可以颠倒位置了import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner cin=new Scanner(System.in);

转移方程为fi][j]=max(f[i-1][j],max(f[k][j-1]))+a[j](j-1比如这么一行数据 3 6 2 3 -7 6 4 -5  所得到的f[i][j]数据如图所示012300000102002055030-2-2-2

把多维压缩到一维，再dp求最大子段。import java.util.Arrays;import java.util.Scanner;public class Main { public static int max_sum(int dp[]) { int max=Integer.MIN_VALUE,sum=0; for(int i=1;i<dp.lengt

求最大递增序列和。状态转移方程：a[i]=max{dp[j]+a[i],dp[i]} 0import java.util.Arrays;import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner cin=new S

很经典的动态规划。import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner cin=new Scanner(System.in); int n=cin.nextInt(); while

LCS。import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner cin=new Scanner(System.in); while(cin.hasNext()) {

下次做题的时候不能中途干其他的了，写着写着忘记之前写的是什么意思了，白白浪费很长时间。对重量进行升序排序，如果重量相等则也按速度降序排序。之后就是LIs了。用一个二维数组dp[len][2],dp[][0]用来记录递增序列的长度,dp[][1]用来记录维持此长度的前一个坐标。逆序打印出来就是了。看网上其他的用的数据结构真不好想的。膜拜下。import java.util.A

动态转移方程：dp[i][j=max{dp[i-1][j-1],dp[i-1][j],dp[i-1][j+1]};其中dp[i][j]表示的是在第i秒j位置上能接到的最多馅饼数目。在i=1时，j除4,5,6位置以外都不能接到馅饼，所以计算先从i=2开始。先对i=1时进行初始化。接到最多馅饼必然是在i最大的时候。进行动态规划时应先按时间进行划分，，先算出一个时间所有位置的状态，而不是