Codechef Bytecode 1-10

最新推荐文章于 2022-01-14 16:47:09 发布
最新推荐文章于 2022-01-14 16:47:09 发布
阅读量802 收藏
点赞数
分类专栏： 动态规划 数论 数学原理 文章标签： 动态规划 数学 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lerenceray/article/details/10084087
版权

这个比赛好像不是很有名气，参加的人不多，前五题感觉比较平，题目有简单的也有中等的，但应该说不难，反正我是AK了。第3，4题还是很好的。

链接：http://www.codechef.com/BTCD2013/

1：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<algorithm>
#include<stack>
#include<deque>
#include<list>
#include<set>
#include<vector>
#include<iomanip>
#include<cctype>
#include<string>
#include<memory>
#include<map>
#include<sstream>
#define mem(a) memset(a, 0, sizeof(a))
#define For(i, n) for(int i = 0; i < (n); ++i)
#define sl(a) strlen(a)
typedef long long LL;
typedef double dou;
const int Mod = 1000000007;
const double eps = 1e-8;
const LL inf = 1e18;
const int inf1 = 1e9;
const int N = 100005;
using namespace std;
 
int a[N], l[N], r[N], dp[N][20];
 
int main()
{
		LL n, m, t, i, j, k;
 
		cin >> t;
		while (t--)
		{
				cin >> n >> m;
				cout << n * m - n - m << endl;			
		}
		return 0;
}
是一个数论结论，（a, b） = 1, a, b > 0 时ax + by (x, y >= 0) 不能表示的最大的整数是a * b - a - b.

证明： a 或 b 是１的情况是显然的，下设a > 1, b > 1.

首先a * b - a - b不能被表示。反证，设a * b - a - b = a * m + b * n 则 a * b = (m + 1)*a + (n + 1) * b.右边系数全部大于1。注意到左边是a的倍数，所以a |（n + 1）*b, 因为（a, b） = 1， 所以a | (n + 1), 所以(n + 1) * b > a * b, 矛盾。
再证a * b - a - b + i (i > 0) 能被表示。因为a，b互质，最大公约数就是1，根据辗转相减的方法知m＊a+n＊b=1，不妨假设m>0,n<0，于是a＊b-a-b+i=a＊b-a-b+i＊(m＊a+n＊b)。因为m>1(m=0意味着n＊b=1不可能的)，所以a＊b-a-b+i＊(m＊a+＊b)=(i＊m-1)a+(a+i＊n-1)＊b，i＊m-1>0，现在只要证明a+i＊n-1>=0，因为i＊m＊a+i＊n＊b=i，如果，|i＊n|>j＊a其中j>0，那么i＊m＊a=i+|i＊n|＊b>j＊a＊b，所以i＊m>j＊b，所以i＊m＊a+i＊n＊b=(i＊m-j＊b)a-(|i＊n|-j＊a)＊b=i，说明|i＊n|>j＊a时，我们就能调整i＊m,i＊n使得|i＊n|<a，因此|i＊n|<=a-1, 所以a+i＊n-1>=0于是得证。

２：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<algorithm>
#include<stack>
#include<deque>
#include<list>
#include<set>
#include<vector>
#include<iomanip>
#include<cctype>
#include<string>
#include<memory>
#include<map>
#include<sstream>
#define mem(a) memset(a, 0, sizeof(a))
#define For(i, n) for(int i = 0; i < (n); ++i)
#define sl(a) strlen(a)
typedef long long LL;
typedef double dou;
const int Mod = 1000000007;
const double eps = 1e-8;
const LL inf = 1e18;
const int inf1 = 1e9;
const int N = 100005;
using namespace std;
 
struct po
{
		list<int>s;
}p[20005];
 
int f[20005], vis[20005];
 
void dfs(int e, int s)
{
		vis[e] = 1;
		f[e] = s;
		list<int> :: iterator it = p[e].s.begin();
		while (it != p[e].s.end())
		{
				if (vis[*it] == 0)
						dfs(*it, e);
				it++;
		}
}
 
int main()
{
		LL n, m, t, i, j, k, x, y;
 
		cin >> t;
		while (t--)
		{
				cin >> n >> x >> y;
				for (i = 1; i <= n; ++i)
				{
						if (i != x)
						{
								cin >> m;
								p[i].s.push_back(m);
								p[m].s.push_back(i);
						}
				}
				dfs(y, y);
				for (i = 1; i <= n; ++i)
				{
						if (i != y)
								cout << f[i] << ' ';
				}
				cout << endl;
				for (i = 1; i <= n; ++i) p[i].s.clear();
				mem(vis);
		}
		return 0;
}

比较水的DFS.不多说。

５：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<algorithm>
#include<stack>
#include<deque>
#include<list>
#include<set>
#include<vector>
#include<iomanip>
#include<cctype>
#include<string>
#include<memory>
#include<map>
#include<sstream>
#define mem(a) memset(a, 0, sizeof(a))
#define For(i, n) for(int i = 0; i < (n); ++i)
#define sl(a) strlen(a)
typedef long long LL;
typedef double dou;
const int Mod = 1000000007;
const double eps = 1e-8;
const LL inf = 1e18;
const int inf1 = 1e9;
const int N = 100005;
using namespace std;
 
int num[200], vis[40], f[200], vv[200];
 
int main()
{
		LL n, m, t, i, j, k, len, cnt, re;
		char s[100];
 
		cin >> t;
		while (t--)
		{
				mem(num), mem(s), mem(vis), mem(f), mem(vv);
				cin >> s;
				len = sl(s);
				cnt = re = 0;
				for (i = 0; i < len; ++i) num[s[i]]++;
				for (i = 0; i < 200; ++i) if (num[i]) cnt++;
				if (cnt == 1)
				{
						cout << (1 << len) - 1 << endl;
				}
				else
				{
				f[s[0]] = 1, vis[1] = re = 1, vv[s[0]] = 1;
				for (i = 1; i < len; ++i) 
				{
						if (vv[s[i]]) re = re * cnt + f[s[i]];
						else
						{
								for (j = 0; j < 40 && vis[j]; ++j);
								vis[j] = 1, f[s[i]] = j, vv[s[i]] = 1;
								re = re * cnt + j;
						}
				}
				cout << re << endl;		
				}
		}
		return 0;
}

（题意就是任给一串字符，你可以认为它是任何进制的数，但求它在十进制下的最小可能值）注意下进制数不能是１就可以了（wa了两次），首位也不能为０。

３和４是两道我觉得比较好的题。

思路都是DP, 其实３只能算递推，并没有涉及到动态保存能带来的好处，其实就是先算好了答案，放在数组里而已。代码中后有着重的地方是关键。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<algorithm>
#include<stack>
#include<deque>
#include<set>
#include<vector>
#include<iomanip>
#include<cctype>
#include<string>
#include<memory>
#include<map>
#include<sstream>
#pragma warning (disable : 4996)
#define mem(a) memset(a, 0, sizeof(a))
#define For(i, n) for(int i = 0; i < (n); ++i)
#define sl(a) strlen(a)
typedef long long LL;
typedef double dou;
const int Mod = 1000000007;
const double eps = 1e-8;
const LL inf = 1e18;
const int inf1 = 1e9;
const int N = 100005;
using namespace std;
#define M 12
LL dp[10][10][600];
LL ans[10][600];
 
int main ()
{
		LL i, j, k, n, m, t, re;
 
		for (i = 1; i < 10; ++i) //最大可取数字为ｉ，首位为ｊ，长度为ｋ
				 dp[i][i][i + 1] = dp[i][0][i + 1] = 1;
		for (i = 1; i < 10; ++i)
				for (k = i + 2; k < 510; ++k) //*****//
						for (j = 0; j <= i; ++j)
						{
								if (j == 0) dp[i][0][k] = (dp[i][1][k - 1] + dp[i - 1][0][k - 1]) % Mod;　//******************//
								else if (j == i) dp[i][i][k] = (dp[i][i - 1][k - 1] + dp[i - 1][i - 1][k - 1]) % Mod;
								else dp[i][j][k] = (dp[i][j - 1][k - 1] + dp[i][j + 1][k - 1]) % Mod;   //******************//
						}
		for (i = 1; i < 10; ++i)	
				for (k = i + 1; k < 510; ++k) //****//
						for (j = 1, ans[i][k] = ans[i][k - 1]; j <= i; ++j) //*****//
							ans[i][k] = (ans[i][k] + dp[i][j][k]) % Mod;
		cin >> t;
		while (t--)
		{
				scanf("%lld%lld", &n, &m);
				if (n > m) printf("0\n");
				else printf("%lld\n", ans[n - 1][m]);
		}
		
		return 0;
}

4：

首先考虑一个两段开的区间(i , j), dp[i][j]表示从a[i]到a[j]的所有可能方案的代价最小值。设两个哨兵0, n+1.枚举i, j 之间所有第一步可取的方案，划归为子问题。取最小即可。最后写出来的代码倒是很简洁。(一开始贪心，猜的策略。。。wa了好多次)。复杂度是Z*Z*Z,10^6可以接受。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<algorithm>
#include<stack>
#include<deque>
#include<list>
#include<set>
#include<vector>
#include<iomanip>
#include<cctype>
#include<string>
#include<memory>
#include<map>
#include<sstream>
#define mem(a) memset(a, 0, sizeof(a))
#define For(i, n) for(int i = 0; i < (n); ++i)
#define sl(a) strlen(a)
typedef long long LL;
typedef double dou;
const int Mod = 1000000007;
const double eps = 1e-8;
const LL inf = 1e18;
const int inf1 = 1e9;
const int N = 100005;
using namespace std;
 
int a[105], dp[105][105];
 
int main()
{
		int  n, m, re, t, i, j, k;
 
		cin >> t;
		while (t--)
		{
				cin >> m >> n;
				mem(dp);
				for (i = 1; i <= n; ++i) cin >> a[i];
				a[n + 1] = m + 1;	
				for (i = 2; i <= n + 1; ++i) 
						for (j = 0; j + i <= n + 1; ++j)
						{
								for (k = j + 1; k < i + j; ++k)
								{
										if (k == j + 1) dp[j][i + j] = (a[i + j] - a[j] - 2 + dp[j][k] + dp[k][i + j]);
										else dp[j][i + j] =  dp[j][i + j] > (a[i + j] - a[j] - 2 + dp[j][k] + dp[k][i + j]) ?  (a[i + j] - a[j] - 2 + dp[j][k] + dp[k][i + j]) : dp[j][i + j];
								}
						}
			cout << dp[0][n + 1] << endl;
		}
		return 0;
}

希望22号，另五道不要忽然变得特别难，能拿个好的名次.^_^

接着写。。。。无力吐槽数据。。。

6：

#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<set>
#include<iostream>
#define LL long long
using namespace std;
 
 set<int> p;
 
bool witness(LL a,LL n)
{
    LL t,d,x;
    d=1;
    int i=ceil(log(n-1.0)/log(2.0)) - 1;
    for(;i>=0;i--)
    {
        x=d;  d=(d*d)%n;
        if(d==1 && x!=1 && x!=n-1) return true;
        if( ((n-1) & (1<<i)) > 0)
            d=(d*a)%n;
    }
    return d==1 ? false : true;
}
 
bool miller_rabin(LL n)
{
    int s[]={2,7,61};
    if(n==2)    return true;
    if(n==1 || ((n&1)==0))    return false;
    for(int i=0;i<3;i++)
        if(witness(s[i], n))    return false;
    return true;
}
 
int main()
{
    int n,cnt, x, y, i, j, t, en;
	cin >> t;             
    while(t--)
    {
				cin >> x >> y;
				cnt=0;
				for (i = 1; i * i < y / 2; ++i)
				{
						en = (int) sqrt(y - i * i + 0.5);
						for (j = i + 1; j <= en; j += 2)
								if (i * i + j * j >= x)
										if (miller_rabin(i * i + j * j)) 
										{
												if (!p.count(i * i + j * j))
												{
														cnt++;
														p.insert(i * i + j * j);
												}
										}
				}
				if (x <= 2 && y >= 2) cnt++;
			   cout << cnt << endl;
			   p.clear();
    }
    return 0;
}

7：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define mem(a) memset(a, 0, sizeof(a))
#define N 100005
#define M 1000005
#define LL long long
#pragma warning (disable : 4996)
using namespace std;
 
struct po
{
		int x, l, cnt, id;
		bool operator < (const po &t) const
		{
				return x < t.x;
		}
}p[N];
 
bool cmp(po a, po b)
{
		return a.id < b.id;
}
 
int main()
{
		int n, i, j, k, t, q, min, sum;
		cin >> t;
		while (t--)
		{
				mem(p);
				cin >> n;
				for (i = 0; i < n; ++i) scanf("%d%d", &(p[i].x), &(p[i].l)), p[i].cnt = 0, p[i].id = i;
				sort(p, p + n);
				for (i = n - 1; i >= 0; --i) 
				{
						p[i].cnt = 1, p[i].l += p[i].x - 1;
						for (j = i + 1; p[j].x <= p[i].l && j < n; ++j) p[i].cnt++, p[i].l = max(p[i].l, p[j].l);
				}
				sort(p, p + n, cmp);
				for (i = 0; i < n; ++i) printf("%d ", p[i].cnt);
				cout << endl;
		}
		return 0;
}
8： 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define mem(a) memset(a, 0, sizeof(a))
#define N 1000005
#define LL long long
#pragma warning (disable : 4996)
using namespace std;
 
int ql, qr, a[N], b[N], num[N], kill;
 
struct no
{
		int cnt, l, r;
}n[4*N];
 
void bld(int x, int l, int r)
{
		int m = (l + r) >> 1;
		n[x].cnt = 0;
		n[x].l = l;
		n[x].r = r;
 		if (r == l) return ;
		else bld(2* x, l, m), bld(2 * x + 1, m + 1, r);
 }
 
void maint(int x, int l, int r)
{
		int ls = x * 2, rs = 2 * x + 1, m = (l + r) >> 1;
		if (l < r)
		{
				n[ls].cnt += n[x].cnt, n[rs].cnt += n[x].cnt;
				maint(ls, l, m), maint(rs, m + 1, r);
		}
		else num[kill++] = n[x].cnt;
}
 
void upd(int x, int l, int r)
{
		int m = (l + r) >> 1, ls = 2 * x, rs = 2 * x + 1;
		if (l == r) n[x].cnt++;
		else
		{
				if (ql <= l&& qr >= r)  n[x].cnt++;
				else 
				{
						if (ql <= m) upd(ls, l, m);
						if(qr > m) upd(rs, m + 1, r);
				}
		}
}
 
 
int main()
{
		int nn, i, j, k, t, q;
		LL re;
		while (cin >> t)
		{
				mem(n), mem(num), kill = 0;
				cin >> nn >> q;
				for (i = 0; i < nn; ++i) cin >> a[i];
				sort(a, a + nn);
				bld(1, 1, nn);
				for (i = 0; i < q; ++i) 
				{
						cin >> ql >> qr;
						upd(1, 1, nn);
				}
				maint(1, 1, nn);
				sort(num, num + nn);
				for (i = 0, re = 0; i < nn; ++i)
						re += a[i] * num[i];
				cout << re << endl;
		}
		return 0;
}
9： 

#include<iostream>
#include<cstring>
#include<set>
#include<cstdio>
#pragma warning (disable : 4996)
using namespace std;
#define N 100005
 
struct po
{
		int x, y;
		bool operator < (const po &t) const
		{
				if (x != t.x) return x < t.x;
				else return y < t.y;
		}
}p[N];
 
set<po> a;
 
int main()
{
		int n, i, j, k, x, y;
		char s[10] = {0};
		po tem;
		set<po>:: iterator iter;
		cin >> n;
		while (n--)
		{
				scanf("%s%d%d", s, &(tem.x), &(tem.y));
				if (s[0] == 'a')
				{
						if (!a.count(tem)) a.insert(tem);
				}
				else if (s[0] == 'e') a.erase(tem);
				else 
				{
						if (a.count(tem))
						{
								iter = a.find(tem);
								iter++;
								if (iter == a.end()) printf("-1\n");
								else printf("%d %d\n", (*iter).x, (*iter).y);
						}
						else
						{
								a.insert(tem);
								iter = a.find(tem);
								iter++;
								if (iter == a.end()) printf("-1\n");
								else printf("%d %d\n", (*iter).x, (*iter).y);
								a.erase(tem);
						}		
				}
		}
		return 0;
}

10： 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define mem(a) memset(a, 0, sizeof(a))
#define N 100005
#define M 1000005
#define LL long long
#pragma warning (disable : 4996)
using namespace std;
int a[N];
 
int main()
{
		int n, i, j, k, t, q, min, sum;
		LL re;
		cin >> t;
		while (t--)
		{
				cin >> n;
				for (i = 0, min = M, re = sum = 0; i < n; ++i) scanf("%d", a + i), min = min > a[i] ? a[i] : min, re ^= a[i], sum += a[i];
				if (re == 0)
						cout << sum - min << endl;
				else cout << "NO\n";
		}
		return 0;
}

水到不能再水。。。。Orz






Lerence1201
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Bytecode-Viewer-2.9.22.jar及jclasslib-library.jar等jar包.zip
01-15
用于直接修改.class文件的jar依赖库
CTF逆向-[羊城杯 2020]Bytecode-WP-Python字节码反编译
serfend's blog
04-12 2596
CTF逆向-[羊城杯 2020]Bytecode-WP-Python字节码反编译 来源：https://buuoj.cn/ 内容：无 附件：https://pan.baidu.com/s/15XJLq9jFV_pOtPMzNXG9XA?pwd=tlwo 提取码：tlwo 答案：GWHT{cfa2b87b3f746a8f0ac5c5963faeff73} 总体思路 反编译汇编成py源码 检查源码逻辑发现是一个约束求解（解方程） 使用z3输入条件得到flag 详细步骤 文件信息，打开发现是Python的
IDEA反编译字节码插件---jclasslib bytecode viewer
曹举的个人博客
01-14 3889
1、安装 File --> Settings 打开设置界面，选择Plugins，在搜索框内输入jclasslib，点击下边搜索 点右边的 Install 安装完成后，重启Idea 2、使用 接下来，看一下怎么使用 想反编译class字节码文件，首先得需要有class字节码文件，所以，得先把项目里的java文件编译成class字节码 首先点idea上方的 Build-->Build Project 接着打开你想反编译字节码文件的java类 然后点Idea上方的 V.
IDEA使用jclasslib-bytecode-viewer插件查看字节码
newbaby2012的专栏
06-18 1418
首先在idea的plugin搜索jclasslib-bytecode-viewer并且安装，重启以后，新建一个类 public class CodeTest { private Integer k; public static void main(String[] args) { int i = 0 ; String str = new String("hello world!"); i = 1; int j = 2;
Java 程序和APK反编译工具(JADX,Bytecode-Viewer,APK Studio)下载与使用方法
weixin_42098295的博客
07-18 249
本文主要介绍Java中，java程序(.dex, .jar, .class, .smali, .zip, .aar, .arsc)和Android(安卓)APK反编译成Java代码工具JADX,bytecode-viewer,Apk Studio的下载地址与使用方法。 原文地址：Java 程序和APK反编译工具(JADX,Bytecode-Viewer,APK Studio)下载与使用方法 ...
apk 与 java_Java 程序和APK反编译工具(JADX,Bytecode-Viewer,APK Studio)下载与使用方法
weixin_32126511的博客
02-28 570
1､JADX的下载与使用方法下载解压缩后的zip文件，进入bin目录并运行：jadx(命令行版本)或者 jadx-gui(图形界面版本)注意：确保已安装Java 8或更高版本的64位版本。不会安装JDK，1) 手动下载解压2) Mac和Linux安装命令Arch linux：sudo pacman -S jadxmacOS：brew install jadx3) 通过源代码安装(需安装JDK 8或...
Bytecode-Viewer-2.9.22
03-01
bytecodeviewer是一款基于图形界面的Java反编译器，Java字节码编辑器，APK编辑器，Dex编辑器，APK反编译器，DEX反编译器。不仅如此，它还是一款Hex查看器，代码搜索器和代码调试器。除此之外，它还具备Smali和...
bytecode worm-开源
07-16
Java类文件反汇编器
SEcuire BYtecode LAnguage-开源
07-05
这个项目是尝试使用能力安全模型设计强类型语言，如 C# 或 Java。 这是一个研究项目。 这个项目也是 async-objects 项目的临时家，它是异步 inte 类的原型
TechTrader Bytecode Toolkit-开源
05-14
TechTrader字节码工具包是用于处理Java字节码的一组高级API。 它的主要目的是对现有的Java类进行运行时和/或编译时增强，或动态创建新的Java类。
HDU 4790 2013 ACM/ICPC 成都赛区现场赛 J. Just Random
Lerence Ray
11-16 2594
hdu上模拟现场赛，做这题的时候很快出了想法，但是就是写错，一直wa, 不过再调试过程中应该算把这题理解地非常透彻了，感觉如果标解是和我思路一样的话，这题的难点就是细节处理，详细的分类讨论。其实后来想明白了以后分类也很清晰自然了，感觉现场老是紧张有点想不清楚，但是还是硬着头皮写，ym那些现场怒A这题的大神。 下面说下我的思路： 对于题目给的区间，[a, b], [c, d]，区间的端点模p的值不
HDUOJ 4767 Bell 长春网络赛1009
Lerence Ray
09-28 2419
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4767 Bell 数背景知识：http://zh.wikipedia.org/wiki/%E8%B4%9D%E5%B0%94%E6%95%B0 当时比赛临时google的，发现有一个递推式可以用：B[n+p] = B[n] +B[n+1] (mod p)，然后又因为一幕中给的大数可以分解为：31*3
Codeforces Round #204 (Div. 1) E. Jeff and Permutation
Lerence Ray
10-07 1713
需要分析： 关键在于对要抓住极值。。。 这道题需要我们抓住最大值。。。。显然我们把所有数按绝对值保存下来都没关系。。（因为可以任意添加负号）。 然后我们考虑这个数列中的最大值，最大值有什么好处？他的符号改变不会影响到其他数，例如绝对值最大为10，在他左边有数字，比如数字是5，那么如果10取10，当5改变符号时，-5 说明一个数列中的绝对值最大的数符号确定以后不会影响其他数无论符号怎么变化，和
Topcoder SRM593 MayTheBestPetWin
Lerence Ray
10-07 1555
Problem Statement   The pony Rainbow Dash wants to choose her pet. There are N animals who want to be her pet. Rainbow Dash numbered them 0 through N-1. To help her make the decision, Rain
USTCOJ 1213 取石子游戏 （经典NIM问题）及一些扩展 与（&） 或 （|）异或 （^）运算性质
Lerence Ray
07-03 1511
题目链接：http://acm.ustc.edu.cn/ustcoj/problem.php?id=1213 在做本题之前，虽然听说过NIM游戏，但并不知道其必胜策略，之前遇到的另一个NIM问题是两堆石子的版本，取石子规则又略有不同，在思考两天之后终于解决了，结论非常优美，用到了数学竞赛知识里的Betty定理，结论和黄金分割有关，这里给个POJ百练上的题目链接：http://poj.grids.
Codeforces Round #202 (Div. 1) D. Turtles
Lerence Ray
10-10 1331
深受数学竞赛影响，一开始在想折线计数方法，想用容斥原理来搞定有不能取的点的情况，事实说明我是个傻吊。。。3000*3000，有可能全是不能取的点，这么多点用个毛线容斥。。。刷题少了！！！！肯定DP啊，而且方程是十分简单，但是题目中有个限制是两条路径不能相交，这就需要大神的指引了！题解给出的是rng_58给的高贵冷艳的Lindström–Gessel–Viennot 引理，见链接：http://en
USTCOJ 1388 钻石
Lerence Ray
06-02 1293
这道题是一道原创的数学题，我的思路是直接算出询问点处的概率概率，仅供大家参考。 题目链接：http://acm.ustc.edu.cn/ustcoj/problem.php?id=1388 经过分析：不难得出，钻石下落后的行为是堆成一个小三角形，然后往两边继续堆，堆至最高点又形成一个稍大的三角形,然后继续往两边堆,如此往复. 因此,我们得出结论,对于n颗钻石堆成的一个小三角形加他的两个边,这
USTCOJ 1239 God Created The Integers
Lerence Ray
05-13 1245
这是我的第一篇博客，现在正在努力学习编程语言中，以此记录学习心得。 题目链接：http://acm.ustc.edu.cn/ustcoj/problem.php?id=1239; 题目大意是要求计算一个与p有关Sp，然后模p后取逆即结果。                               其中p是4k+1型质数p > 10。 这题我们需要以下知识，原理。（主要是二次剩余）
HDUOJ 4751 Divide Groups 2013南京网络赛1004
Lerence Ray
09-21 1229
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4751 不得不吐槽一下坑爹的出题人，题目不知道改了多少个。。。不过也就早过一题，晚过一题的问题（因为只A了一题），弱到不能再弱。吃翔去。。。 题目意思就是把一幅有向图的点分成两个集合，使得每个集合内的点构成完全图。 可以转化成二分图，然后染色解决。我们用邻接矩阵保存边，（有正反），然后重新定义连通
bytecode-viewer-2.10.x.jar
最新发布
07-13
bytecode-viewer-2.10.x.jar是一个Java字节码查看器的JAR文件。字节码是一种中间代码表示形式，它是Java源代码在编译过程中生成的。bytecode-viewer-2.10.x.jar允许开发者查看和分析编译后的Java程序的字节码。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值