response3's People
response3's Issues
gene
import itertools
with open('work.txt', 'w') as w:
f=open('fast.txt', encoding='utf-8')
for i in f:
tem = "RepeatMasker -nolow -no_is -norna -engine ncbi -parallel 4 -lib /public/final.library /public/Lycoris.bp.p_ctg.fasta.cut/"+i+">/public/"+i+ ".log 2>>/public/"+i+".log2; echo This-Work-is-Completed!\n"
a = ""
for j in tem:
if j!='\n':
a = a + j
w.write(a + "\n")
2812
int num[13] = { 0 };
int b[4] = { 6,3,7,1 };
int t[4] = { 1,2,4,8 };
for (int x = 0; x < 4; x++)
{
if (x == 0 || x == 2)
{
for (int i = 0; i < 4; i++)
{
if ((b[x] & t[i]) != 0)
{
printf("第 %d 位为1 \n", i + 1);
num[j] = 1;
j++;
}
else
{
printf("第 %d 位为0 \n", i + 1);
num[j] = 0;
j++;
}
}
}
else if (x==1)
{
for (int i = 0; i < 3; i++)
{
if ((b[x] & t[i]) != 0)
{
printf("第 %d 位为1 \n", i + 1);
num[j] = 1;
j++;
}
else
{
printf("第 %d 位为0 \n", i + 1);
num[j] = 0;
j++;
}
}
}
else
{
for (int i = 0; i < 2; i++)
{
if ((b[x] & t[i]) != 0)
{
printf("第 %d 位为1 \n", i + 1);
num[j] = 1;
j++;
}
else
{
printf("第 %d 位为0 \n", i + 1);
num[j] = 0;
j++;
}
}
}
}
for (int i = 0; i < 13; i++)
{
printf("...num 第几位 %d 为 %d\n", i, num[i]);
}
hahhahh
struct Warrior
{
int Highlevel;
int Clevel;
int Hp;
int Attack;
int Defense;
int Money;
int Yellow_key;
int Blue_key;
int Red_key;
int Sword;
int Shield;
int Buycount;
int getLevel() { return Clevel; }
int getHp() { return Hp; }
int getAttack() { return Attack; }
int getDefend() { return Defense; }
int getMoney() { return Money; }
int getYellow_Key() { return Yellow_key; }
int getBlue_Key() { return Blue_key; }
int getRed_Key() { return Red_key; }
int getClevel() { return Clevel; }
int getSword() { return Sword; }
int getShield() { return Shield; }
void LevelUp() { Clevel++; }
void LevelDown() { Clevel--; }
void Raise_Hp(int hp) { Hp += hp; }
void Lose_Hp(int hp) { Hp -= hp; }
void Raise_Attack(int att) { Attack += att; }
void Raise_Defend(int def) { Defense += def; }
void Get_Money(int money) { Money += money; }
void Spend_Money(int money) { Money -= money; }
void Get_Yellow_Key() { Yellow_key++; }
void Get_Blue_Key() { Blue_key++; }
void Get_Red_Key() { Red_key++; }
void Spend_Yellow_Key() { Yellow_key--; }
void Spend_Blue_Key() { Blue_key--; }
void Spend_Red_Key() { Red_key--; }
void HighLevelUp() { Highlevel++; }
void SetSword(int s) { Sword = s; }
void SetShield(int s) { Shield = s; }
int getBuyCount() { return Buycount; }
void Buy() { Buycount++; }
// void setItems(vector<int> &a) { return ITEMS; }
//bool Fight(Monster m); // 攻击怪物
};
struct Monster
{
};
Warrior w;
Instant Calculator
#define MAXC 1001
#define MAXL 101
using namespace std;
char arr[MAXC][MAXL];
int eva[MAXC];
int idx, len;
int evaluate(int s, int l, int index) {
int opr = 1;
int res = 0;
for (int i = s; i <= l; i++) {
if (arr[index][i] == '+') opr = 1;
else if (arr[index][i] == '-') opr = -1;
else if (arr[index][i] >= '0' && arr[index][i] <= '9') {
int x = arr[index][i] - '0';
if (i + 1 <= l && arr[index][i + 1] >= '0' && arr[index][i + 1] <= '9') {
i++;
x = x * 10 + (arr[index][i] - '0');
}
if (i + 1 <= l && arr[index][i + 1] == '*') {
i += 2;
int y = arr[index][i] - '0';
if (i + 1 <= l && arr[index][i + 1] >= '0' && arr[index][i + 1] <= '9') {
i++;
y = y * 10 + (arr[index][i] - '0');
}
x = y;
}
res += (xopr);
}
}
return res;
}
void init(int mLen, char mSubexp[])
{
idx = 0;
len = mLen;
arr[0][0] = '+';
for (int i = 0; i < mLen; i++) {
arr[0][i + 1] = mSubexp[i];
}
eva[0] = evaluate(0, len, 0);
idx++;
}
int append(char mLink, char mSubexp[])
{
arr[idx][0] = mLink;
for (int i = 1; i <= len; i++) {
arr[idx][i] = mSubexp[i - 1];
}
eva[idx] = eva[idx - 1] + evaluate(0, len, idx);
return eva[idx++];
}
int erase(int mFrom)
{
int r = mFrom / (len + 1);
int c = mFrom % (len + 1);
for (int i = c; i <= len; i++) {
arr[r][i] = arr[r + 1][i];
}
for (int i = r + 2; i < idx; i++) {
for (int j = 0; j <= len; j++) {
arr[i - 1][j] = arr[i][j];
}
}
idx--;
if (r == 0) {
eva[0] = evaluate(0, len, 0);
r++;
}
for (int i = r; i < idx; i++) {
eva[i] = eva[i - 1] + evaluate(0, len, i);
}
return eva[idx - 1];
}
int select(int mFrom, int mTo)
{
int r1 = mFrom / (len + 1);
int c1 = mFrom % (len + 1);
int r2 = mTo / (len + 1);
int c2 = mTo % (len + 1);
int ans = eva[r2 - 1] - eva[r1];
ans += evaluate(c1, len, r1) + evaluate(0, c2, r2);
return ans;
}
daily plan
- 完成热度信息排序
- 加上自锁机制
- 完成调试
Managing Rectangles
#include
int timestamp;
struct Rectangle {
int mid, timestamp;
int sy, sx, ey, ex;
int h, w;
}rect[10001];
struct cmp { bool operator()( Rectangle * a, Rectangle * b) { return a->timestamp > b->timestamp; } };
std::set< Rectangle *, cmp> bucketimestampet[101][101];
void init(int N)
{
for (int i = 1; i <= 10000; i++) rect[i] = {};
for (int i = 0; i <= 100; i++)
for (int j = 0; j <= 100; j++)
bucketimestampet[i][j].clear();
}
void Erase(int sy, int ey, int sx, int ex, Rectangle * cur) {
for (int i = sy; i <= ey; i++)
for (int j = sx; j <= ex; j++)
bucketimestampet[i][j].erase(cur);
}
void addRect(int mID, int mY, int mX, int mHeight, int mWidth)
{
int sy = mY, sx = mX, ey = mY + mHeight - 1, ex = mX + mWidth - 1;
rect[mID] = { mID, ++timestamp, sy, sx, ey, ex, mHeight, mWidth };
for (int i = sy / 100; i <= ey / 100; i++)
for (int j = sx / 100; j <= ex / 100; j++)
bucketimestampet[i][j].insert(&rect[mID]);
}
int check(int mY, int mX)
{
for (auto cur : bucketimestampet[mY / 100][mX / 100]) {
if (cur->sy <= mY && cur->ey >= mY && cur->sx <= mX && cur->ex >= mX) return cur->mid;
}
return 0;
}
void selectAndMove(int y1, int x1, int y2, int x2)
{
int mID = check(y1, x1);
if (!mID) return;
Rectangle * cur = &rect[mID];
Erase(cur->sx / 100, cur->ey / 100, cur->sx / 100, cur->ex / 100, cur);
rect[mID] = { mID, cur->timestamp, y2, x2, y2 + cur->h - 1, x2 + cur->w - 1, cur->h, cur->w };
for (int i = cur->sy / 100; i <= cur->ey / 100; i++)
for (int j = cur->sx / 100; j <= cur->ex / 100; j++)
bucketimestampet[i][j].insert(cur);
}
int moveFront(int mID)
{
if (!rect[mID].mid || !rect[mID].timestamp) return 0;
int sx = rect[mID].sx, sy = rect[mID].sy, ex = rect[mID].ex, ey = rect[mID].ey;
Erase(sy / 100, ey / 100, sx / 100, ex / 100, &rect[mID]);
addRect(mID, sy, sx, rect[mID].h, rect[mID].w);
int r = 0, rid = 0;
for (int i = rect[mID].sy / 100; i <= rect[mID].ey / 100; i++)
for (int j = rect[mID].sx / 100; j <= rect[mID].ex / 100; j++)
for (auto cur : bucketimestampet[i][j]) {
if (&rect[mID] == cur) continue;
if (rect[mID].sx <= cur->ex && rect[mID].sy <= cur->ey && rect[mID].ex >= cur->sx && rect[mID].ey >= cur->sy) {
if (r < cur->timestamp) {
r = cur->timestamp;
rid = cur->mid;
}
}
}
return rid;
}
int selectAndErase(int mY, int mX)
{
int mID = check(mY, mX);
if (mID) {
Erase(rect[mID].sy / 100, rect[mID].ey / 100, rect[mID].sx / 100, rect[mID].ex / 100, &rect[mID]);
rect[mID].timestamp = 0;
}
return mID;
}
swm341
A1 A2
VSYNC PB2_43 PB2_43
HSYNC PB3_42 PM8_57
TFT_DE PB4_pin31 PM11_pin54
LCDCLK PB5_pin40 PB5_pin40(?)
LCD_PWM PD9_76
LCD_CS 45
LCD_DAT 47
LCD_CLK 46
LCD_RST PD1_85 PD1_85(可控)
News Notification
#include <unordered_map>
#include
using namespace std;
struct News{
bool valid;
int mnewid, sendtime, cid;
int map;
} pool[30011];
struct User
{
int que[30001], idx;
} user[501];
struct Channel
{
int userlist[501], n;
} channel[501];
unordered_map <int, int> hashnew;
unordered_map <int, int> hashuser;
unordered_map <int, int> hashchan;
int cntnew, cntuser, cntchan;
struct cmp{
bool operator ()(int i, int j) {
if(pool[i].sendtime != pool[j].sendtime) return pool[i].sendtime > pool[j].sendtime;
return pool[i].mnewid > pool[j].mnewid;
}
};
priority_queue <int, vector, cmp> heapTime;
int N, K;
void init(int nn, int kk){
N = nn; K = kk;
heapTime = priority_queue <int, vector, cmp>();
hashchan.clear();
hashuser.clear();
hashnew.clear();
cntchan = 0; cntnew = 0; cntuser = 0;
for(int i = 1; i <= N; i++) user[i].idx = -1;
for(int i = 1; i <= K; i++) channel[i].n = 0;
}
void update(int mtime) {
while (!heapTime.empty() && pool[heapTime.top()].sendtime <= mtime) {
int nid = heapTime.top();
heapTime.pop();
if(pool[nid].valid == 1) {
int cid = pool[nid].cid;
for(int i = 0; i < channel[cid].n; i++) {
int uid = channel[cid].userlist[i];
user[uid].que[++user[uid].idx] = nid;
}
}
}
}
void registerUser(int mtime, int muid, int mnum, int mchan[]){
update(mtime);
int uid;
if(hashuser[muid] == 0) hashuser[muid] = ++cntuser;
uid = hashuser[muid];
for(int i = 0; i < mnum; i++) {
int mchanid = mchan[i];
int cid;
if(hashchan[mchanid] == 0) hashchan[mchanid] = ++cntchan;
cid = hashchan[mchanid];
channel[cid].userlist[channel[cid].n++] = uid;
}
}
int offerNews(int mtime, int mnewid, int mdelay, int mchanid) {
int nid = ++cntnew;
hashnew[mnewid] = nid;
int cid;
if(hashchan[mchanid] == 0) hashchan[mchanid] = ++cntchan;
cid = hashchan[mchanid];
pool[nid].cid = cid;
pool[nid].mnewid = mnewid;
pool[nid].sendtime = mtime + mdelay;
pool[nid].valid = 1;
heapTime.push(nid);
return channel[cid].n;
}
void cancelNews(int mtime, int mnewid) {
if(hashnew[mnewid] == 0) return;
int nid = hashnew[mnewid];
if(pool[nid].valid == 0) return;
if(pool[nid].valid == 1) {
pool[nid].valid = 0;
return;
}
}
int checkUser(int mtime, int muid, int mretid[]){
int rescnt = 0;
int uid = hashuser[muid];
update(mtime);
for(int i = user[uid].idx; i >= 0; i--) {
int nid = user[uid].que[i];
if(pool[nid].valid == 0) continue;
if(rescnt < 3) mretid[rescnt] = pool[nid].mnewid;
rescnt++;
}
user[uid].idx = -1;
return rescnt;
}
Morning Commute Radio
#include
using namespace std;
int prices[100000];
int n;
int bit[100000 + 1];
vectorroad[1001];
//分解
void add(int idx, int delta)
{
for (; idx < n; idx += idx & -idx) {
bit[idx] += delta;
}
}
//合并
int sum(int idx)
{
register int ret = 0;
for (; idx != 0; idx -= idx & -idx) {
ret += bit[idx];
}
return ret;
}
void init(int N, int M, int mType[], int mTime[])
{
for (int i = 0; i < M; i++)
road[i].clear();
n = N;
for (register int i = 1; i < N; i++)
bit[i] = 0;
for (register int i = 0; i < N - 1; i++) {
prices[i] = mTime[i];
add(i + 1, mTime[i]);
road[mType[i]].push_back(i);
}
}
void destroy()
{
}
void update(int mID, int mNewTime)
{
add(mID + 1, mNewTime - prices[mID]);
prices[mID] = mNewTime;
}
int updateByType(int mTypeID, int mRatio256)
{
register int ret = 0, newTime;
for (auto i = road[mTypeID].begin(); i != road[mTypeID].end(); i++)
{
newTime = (prices[*i] * mRatio256) >> 8;
update(*i, newTime);
ret += newTime;
}
return ret;
}
int calculate(int mA, int mB)
{
return mA > mB ? sum(mA) - sum(mB) : sum(mB) - sum(mA);
}
Block Stacking Game
#include<string.h>
#include
using namespace std;
#define MAX(a,b) (a>b?a:b)
#define MIN(a,b) (a<b?a:b)
#define MAXC 1000000
//利用线段树进行记录,经验表明开4倍空间不会越界,也没有超过256MB限制
int mSegTree[4 * MAXC], mMin[4 * MAXC], mMax[4 * MAXC];
struct Result
{
int top;
int count;
};
//整体思路利用线段树的特性去存储不同的值,并进行更新,整体查询复杂度在O(logN)
long long int mTotal;
int C;
void update(int idx, int sSt, int sEn, int qSt, int qEn, int mChange)
{
//lazy Propagation
//进行修改时,事实上并没有真的修改,是给区间打上一段标记,一旦查询时发现这个节点有标记,就把标记下推到它的两个子节点
if (mSegTree[idx] != 0)
{
register int val = mSegTree[idx];
mMin[idx] += val;
mMax[idx] += val;
mSegTree[idx] = 0;
if (sSt != sEn)
{
mSegTree[(idx << 1) + 1] += val;
mSegTree[(idx << 1) + 2] += val;
}
}
//区间无交集,进行剪枝操作
if (qEn < sSt || sEn<qSt || sSt>sEn)
return;
//从顶开始
if (sSt >= qSt && sEn <= qEn)
{
mMin[idx] += mChange;
mMax[idx] += mChange;
if (sSt != sEn)
{
mSegTree[(idx << 1) + 1] += mChange;
mSegTree[(idx << 1) + 2] += mChange;
}
return;
}
register int mid = (sSt + sEn) >> 1;
//mid则为中间点,左儿子的结点区间为[sSt,mid],右儿子的结点区间为[mid,sEn]
update((idx << 1) + 1, sSt, mid, qSt, qEn, mChange); ////递归构造左儿子结点
update((idx << 1) + 2, mid + 1, sEn, qSt, qEn, mChange); //递归构造右儿子结点
//最大最小的更新
mMin[idx] = MIN(mMin[(idx << 1) + 1], mMin[(idx << 1) + 2]);
mMax[idx] = MAX(mMax[(idx << 1) + 1], mMax[(idx << 1) + 2]);
}
void init(int C)
{
::C = C;
mTotal = 0;
memset(mSegTree, 0, sizeof(mSegTree));
memset(mMin, 0, sizeof(mMin));
memset(mMax, 0, sizeof(mMax));
}
Result dropBlocks(int mCol, int mHeight, int mLength)
{
//Do RangeUpdate->Add total blocks->Subtract blocks=no of rows filled
update(0, 0, C - 1, mCol, mCol + mLength - 1, mHeight);
mTotal += (mHeight * mLength);
Result ret = { mMax[0] - mMin[0],(mTotal - (C * mMin[0])) % MAXC };
return ret;
}
Announcement For Workers
#include
#include<unordered_map>
#include
using namespace std;
struct MyStruct
{
int start;
int end;
}pool[9000];
//start
set<pair<int, pair<int, int>>>sset1;
int numcnt;
unordered_map<int, int>umap;
void init() {
sset1.clear();
umap.clear();
numcnt = 0;
return;
}
int add(int mId, int mStart, int mEnd) {
if (umap.count(mId) == 1)
{
int index = umap[mId];
sset1.erase(make_pair(pool[index].start, make_pair(pool[index].end, index)));
umap[mId] = numcnt;
pool[numcnt].start = mStart;
pool[numcnt].end = mEnd;
sset1.emplace(make_pair(mStart, make_pair(mEnd, numcnt)));
numcnt++;
return umap.size();
}
umap[mId] = numcnt;
pool[numcnt].start = mStart;
pool[numcnt].end = mEnd;
sset1.emplace(make_pair(mStart, make_pair(mEnd, numcnt)));
numcnt++;
return umap.size();
}
int remove(int mId) {
if (umap.count(mId))
{
int index = umap[mId];
sset1.erase(make_pair(pool[index].start, make_pair(pool[index].end, index)));
umap.erase(mId);
return umap.size();
}
return umap.size();
}
struct cmd {
bool operator()(const pair<int, pair<int, int>> a, pair<int, pair<int, int>> b) const {
return a.second.first > b.second.first;
}
};
int announce(int mDuration, int M) {
int e;
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>, cmd> pq;
for (auto i : sset1) {
e = i.first + mDuration - 1;
pq.push(i);
while (!pq.empty()) {
if (pq.top().second.first < e)
{
pq.pop();
}
else
{
break;
}
}
if (pq.size() >= M)
{
return i.first;
}
}
return -1;
}
Seat Reservation
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#include
#include
#include
#include
using namespace std;
#define MAXID 50003
#define MAXN 2003
int N;
struct theater {
int id;
int arr[101];
int avalcount;
}tDB[MAXN + 1];
int mIDtotID[MAXID + 1];
int vis[101];
int tobemarked[101];
int curravalcount;
struct Result {
int id;
int num;
};
int dir[4] = { -1,1,-10,10 };
bool bfs(int start, int tID, int mID, int K) {
priority_queue<int, vector<int>, greater<int>>pq;
for (int i = 1; i <= 100; i++) {
tobemarked[i] = 0;
}
int count = 0;
pq.push(start);
while (!pq.empty()) {
int cur = pq.top();
pq.pop();
count++;
tobemarked[cur] = 1;
vis[cur] = 1;
if (count == K)break;
for (int j = 0; j < 4; j++) {
if (cur % 10 == 0 && j == 1)
continue;
else if (cur % 10 == 1 && j == 0)
continue;
int newseatno = cur + dir[j];
if (newseatno >= 1 && newseatno <= 100 && vis[newseatno] == 0 && tDB[tID].arr[newseatno] == 0 ) {
pq.push(newseatno);
vis[newseatno] = 1;
}
}
}
curravalcount -= count;
if (count == K) {
for (int i = 1; i <= 100; i++) {
if (tobemarked[i]) {
tDB[tID].arr[i] = mID;
}
}
return true;
}
return false;
}
void init(int N)
{
::N = N;
for (int i = 0; i <= MAXID; i++)mIDtotID[i] = 0;
for (int i = 1; i <= N; i++) {
tDB[i].id = i;
tDB[i].avalcount = 100;
for (int j = 1; j <= 100; j++) {
tDB[i].arr[j] = 0;
}
}
}
Result reserveSeats(int mID, int K)
{
Result res;
res.id = 0;
res.num = 0;
for (int i = 1; i <= N; i++) {
curravalcount = tDB[i].avalcount;
if (curravalcount >= K) {
for (int j = 1; j <= 100; j++)vis[j] = 0;
for (int j = 1; j <= 100; j++) {
if (tDB[i].arr[j] == 0 && vis[j] == 0 && curravalcount >= K) {
if (bfs(j, i, mID, K)) {
res.id = i;
res.num = j;
mIDtotID[mID] = i;
tDB[i].avalcount -= K;
return res;
}
}
}
}
}
return res;
}
Result cancelReservation(int mID)
{
Result res;
res.id = 0;
res.num = 0;
int tid = mIDtotID[mID];
res.id = tid;
int c = 0;
for (int i = 1; i <= 100; i++) {
if (tDB[tid].arr[i] == mID) {
res.num += i;
tDB[tid].arr[i] = 0;
c++;
}
}
tDB[tid].avalcount += c;
return res;
}
Phylogenetic Tree
#include <unordered_map>
#include
using namespace std;
#define MAXL (11)
#define SPC_MAX 50001
struct MyStruct
{
int parent;
int child_num[5];
}species[SPC_MAX];;
unordered_map<string, int> umap;
int cnt;
void init(char mRootSpecies[MAXL])
{
cnt = 1;
umap.clear();
for (int i = 0; i < SPC_MAX; i++) {
species[i].parent = -2;
for (int j = 0; j < 5; j++) {
species[i].child_num[j] = 0;
}
}
umap[mRootSpecies] = cnt;
species[cnt].parent = -1;
species[cnt].child_num[0] = 1;
cnt++;
}
void add(char mSpecies[MAXL], char mParentSpecies[MAXL])
{
umap[mSpecies] = cnt;
int pid = umap[mParentSpecies];
species[cnt].parent = pid;
species[cnt].child_num[0] = 1;
for (int i = 1; i < 5; i++) {
if (pid == -1) break;
species[pid].child_num[i]++;
pid = species[pid].parent;
}
cnt++;
}
int getDistance(char mSpecies1[MAXL], char mSpecies2[MAXL])
{
int idx1 = umap[mSpecies1];
int idx2 = umap[mSpecies2];
int count = 0;
while (idx1 != idx2) {
if (idx1 > idx2) {
idx1 = species[idx1].parent;
}
else {
idx2 = species[idx2].parent;
}
count++;
}
return count;
}
int getCount(char mSpecies[MAXL], int mDistance)
{
int dst = mDistance;
int cur = umap[mSpecies];
int pid = species[cur].parent;
int count = species[cur].child_num[dst];
//不是根节点的处理情况,是根节点直接返回
while (dst > 0 && pid != -1) {
count += species[pid].child_num[dst - 1];
if (dst - 1 > 0) {
count -= species[cur].child_num[dst - 2];
}
dst--;
cur = pid;
pid = species[pid].parent;
}
return count;
}
xy
#include<unordered_map>
#include
using namespace std;
int term = 10000;
unordered_map<int, int>all[10001];
unordered_map<string, int>no;
int num;
void init()
{
num = 0;
no.clear();
}
void assign(char mName[], char mPolynomial[])
{
no[mName] = num;
all[num].clear();
register int x = 0, y = 0, c = 1, sign = 1;
for (register int i = 0; mPolynomial[i] != '\0';)
{
if ('0' <= mPolynomial[i]&&mPolynomial[i]<='9')
{
c = mPolynomial[i] - '0';
i++;
}
if (mPolynomial[i]=='X')
{
i++;
x++;
if (mPolynomial[i]=='^')
{
x = mPolynomial[++i] - '0';
i++;
}
}
if (mPolynomial[i] == 'Y')
{
i++;
y++;
if (mPolynomial[i] == '^')
{
y = mPolynomial[++i] - '0';
i++;
}
}
if (mPolynomial[i] == '+' || mPolynomial[i] == '-')
{
all[num][x * 1000 + y] += sign * c;
if (mPolynomial[i]=='+')
{
sign = 1;
}
else
{
sign = -1;
}
x = 0, y = 0, c = 1;
i++;
}
}
all[num][x * 1000 + y] += sign * c;
num++;
}
void compute(char mNameR[], char mNameA[], char mNameB[], int mOp)
{
no[mNameR] = num;
all[num].clear();
int ida = no[mNameA];
int idb = no[mNameB];
if (mOp < 2)
{
for (auto i = all[ida].begin(); i != all[ida].end(); i++)
{
all[num][i->first] += i->second;
}
for (auto i = all[idb].begin(); i != all[idb].end(); i++)
{
all[num][i->first] += !mOp ? i->second : -i->second;
}
}
else
{
register int xa, xb, xc, ya, yb, yc;
for (auto i = all[ida].begin(); i != all[ida].end(); i++)
{
xa = i->first / 1000, xb = i->first % 1000, xc = i->second;
for (auto j = all[idb].begin(); j != all[idb].end(); j++)
{
ya = j->first / 1000, yb = j->first % 1000, yc = j->second;
all[num][(xa + ya) * 1000 + xb + yb] += (xc * yc) % term;
}
}
}
num++;
}
int getCoefficient(char mName[], int mDegreeX, int mDegreeY)
{
return (all[no[mName]][mDegreeX * 1000 + mDegreeY] + term) % term;
}
int getpow(int x, int y)
{
register int ans = 0;
if (!x||y)
{
ans = 1;
for (register int i = 0; i < x; i++)
{
ans = (ans * y) % term;
}
}
return ans;
}
int calcPolynomial(char mName[], int mX, int mY)
{
int id = no[mName];
register int x, y, c, X, Y, ans = 0;
for (auto i = all[id].begin(); i != all[id].end(); i++)
{
x = i->first / 1000;
y = i->first % 1000;
c = i->second;
X = getpow(x, mX);
Y = getpow(y, mY);
ans = (ans + ((long long int)X * Y * c)) % term;
}
return ans >= 0 ? ans : (ans + term);
}
werwerwe
using namespace std;
struct block {
int sc;
int len;
int ec;
int time;
int block[10000];
}B[1000];
int r, c;
int idx;
void init(int R, int C)
{
r = R;
c = C;
idx = 0;
}
int dropBlocks(int mTimestamp, int mCol, int mLen)
{
int total =0;
for (int i = idx - 1; i >= 0; i--) {
if (mTimestamp - B[i].time < r)
total += B[i].len;
}
B[idx].sc = mCol;
B[idx].ec = mCol + mLen;
B[idx].len = mLen;
B[idx].time = mTimestamp;
for (int i = mCol; i < mCol + mLen; i++)
B[idx].block[i] = 1;
total += mLen;
idx++;
return total;
}
int removeBlocks(int mTimestamp)
{
int total = 0;
int visit[10000] = { 0 };
for (int i = 0; i < idx; i++) {
if (mTimestamp - B[i].time < r) {
for (int j = B[i].sc; j < B[i].ec; j++) {
if (visit[j] == 0 && B[i].block[j] == 1) {
visit[j] = 1;
B[i].block[j] = 0;
B[i].len--;
}
}
total += B[i].len;
}
}
return total;
}
School Assignment
#include
#include
#include<unordered_map>
#include
#include
using namespace std;
int c, n;
struct MyStruct
{
vectorse;
int id;
int school;
int max_distance;
unordered_map<int, int>record;
}s[7501];
struct cmp
{
bool operator()(int a, int b)const {
if (s[a].max_distance != s[b].max_distance)
{
return s[a].max_distance > s[b].max_distance;
}
else
{
return s[a].id < s[b].id;
}
}
};
set<int, cmp>school[10];
set<int, cmp>all;
unordered_map<int, int>stu;
int sum;
pair<int, int>sss[10];
void init(int C, int N, int mX[], int mY[]) {
c = C;
n = N;
sum = 0;
stu.clear();
all.clear();
for (register int i = 0; i < N; i++)
{
school[i].clear();
sss[i] = make_pair(mX[i], mY[i]);
}
for (register int i = 0; i < 7501; i++)
{
s[i].se.clear();
s[i].record.clear();
}
return;
}
void arrange(int num)
{
for (auto i : s[num].se)
{
//按距离最近的开始遍历选择,如果还有空位置就可以直接加入
if (school[i].size() < c)
{
s[num].school = i;
school[i].emplace(num);
all.emplace(num);
return;
}
else
{
//人已经满了会产生3种情况;
// 1.跟最后的一名的距离都小于,把原来学校最小优先级的学生都挤不走,只能到下一轮
//2.跟最后的一名的距离相等,但是id却大于,到下一轮
//3. 跟最后的一名的距离相等,但是id却小于,把最后一名挤走
//4.比最后一名距离大,直接把最后一名挤走
int n = *school[i].rbegin();
if (s[n].max_distance == s[num].max_distance)
{
//3
if (s[n].id > s[num].id)
{
s[num].school = i;
school[i].emplace(num);
all.emplace(num);
all.erase(n);
school[i].erase(n);
//按照一层一层往下推,直到全安排好
arrange(n);
return;
}
}
else if (s[n].max_distance < s[num].max_distance)
{
//4
s[num].school = i;
school[i].emplace(num);
all.emplace(num);
all.erase(n);
school[i].erase(n);
//按照一层一层往下推,直到全安排好
arrange(n);
return;
}
}
}
}
int add(int mStudent, int mX, int mY) {
stu[mStudent] = sum;
vector<pair<int, int>>tem;
for (register int i = 0; i < n; i++)
{
int x = sss[i].first - mX < 0 ? mX - sss[i].first : sss[i].first - mX;
int y = sss[i].second - mY < 0 ? mY - sss[i].second : sss[i].second - mY;
tem.push_back(make_pair(x + y, i));
}
sort(tem.begin(), tem.end());
//该同学的最远距离
s[sum].max_distance = tem.rbegin()->first;
s[sum].id = mStudent;
//把该同学依次最近的学校给输入进来
int g = 1;
for (auto i : tem)
{
s[sum].se.push_back(i.second);
s[sum].record[i.second] = g;
g++;
}
for (auto i : tem)
{
//按距离最近的开始遍历选择,如果还有空位置就可以直接加入
if (school[i.second].size() < c)
{
s[sum].school = i.second;
school[i.second].emplace(sum);
all.emplace(sum);
sum++;
return i.second;
}
else
{
//人已经满了会产生3种情况;
// 1.跟最后的一名的距离都小于,把原来学校最小优先级的学生都挤不走,只能到下一轮
//2.跟最后的一名的距离相等,但是id却大于,到下一轮
//3. 跟最后的一名的距离相等,但是id却小于,把最后一名挤走
//4.比最后一名距离大,直接把最后一名挤走
int num = *school[i.second].rbegin();
if (s[num].max_distance == s[sum].max_distance) //tem.rbegin()->first)
{
//3
if (s[num].id > mStudent)
{
s[sum].school = i.second;
//添加新的
school[i.second].erase(num);
all.erase(num);
all.emplace(sum);
school[i.second].emplace(sum);
//删除旧的
//按照一层一层往下推,直到全安排好
arrange(num);
sum++;
return i.second;
}
}
else if (s[num].max_distance < s[sum].max_distance)
{
//4
s[sum].school = i.second;
//添加新的
school[i.second].erase(num);
all.erase(num);
all.emplace(sum);
school[i.second].emplace(sum);
//删除旧的
//school[i.second].erase(num);
//按照一层一层往下推,直到全安排好
arrange(num);
sum++;
return i.second;
}
}
}
}
void brrange(int result, int pos)
{
//不需要移动
if (school[s[result].school].size() < c)
{
//把原来的删除
school[s[result].school].erase(result);
//添加到新的位置
s[result].school = pos;
school[pos].emplace(result);
return;
}
else
{
//满了要移动,每次找出要移动的下一个点
auto it = school[s[result].school].rbegin();
int num1 = s[*it].id;
num1 = stu[num1];
int city = s[*it].school;
auto it1 = all.find(result);
it1++;
school[s[result].school].erase(result);
s[result].school = pos;
school[pos].emplace(result);
for (it1; it1 != all.end(); it1++)
{
//如果result的优先级是要比他现在的高,证明他就是要被移动的
if (s[*it1].record[city] < s[*it1].record[s[*it1].school])
{
brrange(*it1, city);
break;
}
}
}
}
int remove(int mStudent) {
int result = s[stu[mStudent]].school;
int num = stu[mStudent];
//stu.erase(mStudent);
//未满谁也不移动
if (school[result].size() < c)
{
stu.erase(mStudent);
school[result].erase(num);
all.erase(num);
return result;
}
//满了要移动,每次找出要移动的下一个点
auto it = school[result].rbegin();
int num1 = s[*it].id;
num1 = stu[num1];
auto it1 = all.find(num1);
it1++;
//删除原来的
stu.erase(mStudent);
school[result].erase(num);
all.erase(num);
for (it1; it1 != all.end(); it1++)
{
//如果result的优先级是要比他现在的高,证明他就是要被移动的
if (s[*it1].record[result] < s[*it1].record[s[*it1].school])
{
brrange(*it1, result);
break;
}
}
return result;
}
int status(int mSchool) {
return school[mSchool].size();
}
Producing Machines
#include<unordered_map>
#include
#include
#define MAX_NUM 25000
using namespace std;
struct machines
{
int id;
int time;
}machines[MAX_NUM];
unordered_map<int, int>umap;
vectorcall;
int index;
struct cmp
{
bool operator()(int a,int b)const {
if (machines[a].time!=machines[b].time)
{
return machines[a].time > machines[b].time;
}
else
{
return machines[a].id > machines[b].id;
}
}
};
set<int, cmp>sset;
void regist(int id,int time) {
index++;
umap[id] = index;
machines[index].id = id;
machines[index].time = time;
sset.insert(index);
}
void init(int N, int mId[], int mTime[]) {
umap.clear();
sset.clear();
index = 0;
for (int i = 0; i < N; i++)
{
regist(mId[i], mTime[i]);
}
return;
}
int add(int mId, int mTime) {
if (umap.find(mId)==umap.end())
{
regist(mId, mTime);
}
else
{
sset.erase(umap[mId]);
machines[umap[mId]].time = mTime;
sset.insert(umap[mId]);
}
return sset.size();
}
int remove(int K) {
for (int i = 0; i < K; i++)
{
int id = machines[*sset.begin()].id;
umap.erase(id);
sset.erase(sset.begin());
}
return machines[*sset.begin()].id;
}
int binary(int l,int h ,int m) {
call.clear();
int low = l;
int high = h;
int mid;
int i = 0;
int temp;
int count1=h;
for (auto it=sset.begin();it!=sset.end();it++)
{
call.push_back(machines[*it].time);
i++;
}
//二分法的核心过程了
while (low<=high) {
temp = 0;
mid = (low + high) >>1;
for (int j = 0; j < i; j++)
{
temp = temp + (mid / call[j]);
}
if (temp>=m)
{
count1 = mid;
high = mid - 1;
}
else
{
low = mid + 1;
}
}
return count1;
}
int produce(int M) {
int count1 = 0;
auto it = sset.rbegin();
count1 = binary(0,M*(machines[*it].time),M);
return count1;
}
nes
Producing Machines
#include
#include<unordered_map>
#include
using namespace std;
struct MyStruct
{
int id;
int time;
}machines[25000];
unordered_map<int, int>umap;
int index;
struct cmp
{
bool operator()(int a, int b)const {
if (machines[a].time!=machines[b].time)
{
return machines[a].time > machines[b].time;
}
else
{
return machines[a].id > machines[b].id;
}
}
};
set<int, cmp>sset;
void init(int N, int mId[], int mTime[]) {
sset.clear();
umap.clear();
index = 0;
for (int i = 0; i < N; i++)
{
index++;
machines[index].id = mId[i];
machines[index].time = mTime[i];
umap[mId[i]] = index;
sset.emplace(index);
//index++;
}
}
int add(int mId, int mTime) {
//找到
if (umap.count(mId))
{
//先删除后更新
int idx = umap[mId];
sset.erase(idx);
machines[idx].time = mTime;
sset.emplace(idx);
}
//没找到
else
{
index++;
machines[index].id = mId;
machines[index].time = mTime;
umap[mId] = index;
sset.emplace(index);
//index++;
}
return sset.size();
}
int remove(int K) {
for (int i = 0; i < K; i++)
{
//sset.erase(sset.begin());
//********************
umap.erase(machines[*sset.begin()].id);
sset.erase(sset.begin());
}
return machines[*sset.begin()].id;
}
//二分计算本题的核心所在
int binary(int l,int h,int M)
{
int low = l;
int high = h;
int middle, cnt;
vectorcall;
int ii=0;
//**************
cnt = h;
for (auto i = sset.begin(); i != sset.end(); i++)
{
call.push_back(machines[*i].time);
ii++;
}
while (low<=high)
{
middle = (low + high) / 2;
int tem = 0;
for (int i = 0; i < ii; i++)
{
//**************
tem = tem + (middle / call[i]);
}
if (tem>=M)
{
//*********************
cnt = middle;
high = middle - 1;
}
else
{
low = middle + 1;
}
}
return cnt;
}
int produce(int M) {
int cnt = 0;
int mintime = machines[*sset.rbegin()].time;
cnt = binary(0, M * mintime, M);
return cnt;
}
intsant
#include
#include
#include
using namespace std;
string dbStr[1007];
int value[1007];
int len;
int idx;
int total;
int calculate(string str, int start, int end) {
int ans = 0;
int sign = 1;
for (register int i = start; i < end; i++)
{
int tem = 0;
if (str[i]=='+')
sign = 1;
if (str[i] == '-')
sign = -1;
if (str[i] >= '0' && str[i] <= '9')
{
tem = str[i] - '0';
if (i + 1 < end && str[i + 1] >= '0' && str[i + 1] <= '9')
{
tem = tem * 10 + (str[i + 1] - '0');
i++;
}
}
if (i + 1 < end && str[i + 1] == '*')
{
int x = 0;
i += 2;
x = str[i] - '0';
if (i + 1 < end && str[i + 1] >= '0' && str[i + 1] <= '9')
{
x = x * 10 + (str[i + 1] - '0');
i++;
}
tem = tem * x;
}
ans += tem * sign;
}
return ans;
}
void init(int mLen, char mSubexp[])
{
len = mLen + 1;
idx = 0;
total = 0;
dbStr[idx] = mSubexp;
dbStr[idx] = '+' + dbStr[idx];
value[idx] = calculate(dbStr[idx], 0, len);
total += value[idx];
idx++;
}
int append(char mLink, char mSubexp[])
{
dbStr[idx] = mSubexp;
dbStr[idx] = mLink + dbStr[idx];
value[idx] = calculate(dbStr[idx], 0, len);
total += value[idx];
idx++;
return total;
}
int erase(int mFrom)
{
int r = mFrom / len;
int c = mFrom % len;
total -= value[r];
if (c != 0) {
total -= value[r + 1];
for (int i = c; i < len; i++) {
dbStr[r][i] = dbStr[r + 1][i];
}
value[r] = calculate(dbStr[r], 0, len);
total += value[r];
r++;
}
for (int i = r; i < idx; i++) {
dbStr[i] = dbStr[i + 1];
value[i] = value[i + 1];
}
idx--;
return total;
}
int select(int mFrom, int mTo)
{
int ans = 0;
int sr = mFrom / len;
int sc = mFrom % len;
int er = mTo / len;
int ec = mTo % (len);
if (sr == er) {
ans = calculate(dbStr[sr], sc, ec + 1);
return ans;
}
ans += calculate(dbStr[sr], sc, len);
ans += calculate(dbStr[er], 0, ec + 1);
for (int x = sr + 1; x < er; x++) {
ans += value[x];
}
return ans;
}
1225
//author: Liu Heng
#include <U8g2lib.h>
#include <Arduino_GFX_Library.h>
#include <Arduino.h>
#include <WiFi.h>
#include <stdio.h>
#include <FS.h>
#include <SD.h>
#include <SD_MMC.h>
#include "material.h"
#include "map.h"
#include "mota_bin.h"
#include "warrior.h"
#include "monster.h"
#define GFX_BL 48 // default backlight pin, you may replace DF_GFX_BL to actual backlight pin
const int yyy = 13;
Arduino_DataBus bus = new Arduino_ESP32SPI(41 / DC /, 10 / CS /, 12 / SCK /, 11 / MOSI /, GFX_NOT_DEFINED / MISO */);
Arduino_ST7789 gfx = new Arduino_ST7789(bus, 42 / RST /, 0 / rotation /, true / IPS */, 240, 320, 0, 0);
int rc;
/*
#define SDMMC_D2 33 // SDMMC Data2
#define SDMMC_D3 4 //34 // SDMMC Data3 / SPI CS
#define SDMMC_CMD 5 // SDMMC CMD / SPI MOSI
#define SDMMC_CLK 6 // SDMMC CLK / SPI SCK
#define SDMMC_D0 7 // SDMMC Data0 / SPI MISO
#define SDMMC_D1 38 // SDMMC Data1
*/
#define SDMMC_D2 16 // SDMMC Data2
#define SDMMC_D3 4 //34 // SDMMC Data3 / SPI CS
#define SDMMC_CMD 5 // SDMMC CMD / SPI MOSI
#define SDMMC_CLK 6 // SDMMC CLK / SPI SCK
#define SDMMC_D0 7 // SDMMC Data0 / SPI MISO
#define SDMMC_D1 15 // SDMMC Data1
int16_t h, xOffset, yOffset;
//所有游戏图片的像素指针
//商店
uint16_t *shop_m;
uint16_t *shop_l;
uint16_t *shop_r;
//@@@@@@@@@@ 敌人
//1
//初级卫兵
uint16_t *gate_keeper_c;
//绿史莱姆
uint16_t *green_slime;
//红史莱姆
uint16_t *red_slime;
//蝙蝠
uint16_t *bat;
//法师
uint16_t *priest;
//骷髅队长
uint16_t *skeleton_a;
//骷髅士兵
uint16_t *skeleton_b;
//骷髅人
uint16_t *skeleton_c;
//2
//大史莱姆
uint16_t *big_slime;
//大蝙蝠
uint16_t *big_bat;
//石头人
uint16_t *rock;
//高级法师
uint16_t *super_priest;
//吸血鬼
uint16_t *vampire;
//兽人武士
uint16_t *zombine_knight;
//兽人
uint16_t *zombine;
//3
//中级卫兵
uint16_t *gate_keeper_b;
//鬼战士
uint16_t *ghost_solider;
//骑士队长
uint16_t *gold_knight;
//骑士
uint16_t *knight;
//幽灵
uint16_t *slime_man;
//战士
uint16_t *solider;
//双手剑士
uint16_t *swords_man;
//5
//黑暗骑士
uint16_t *dark_knight;
//高级卫兵
uint16_t *gate_keeper_a;
//高级巫师
uint16_t *magician_a;
//初级巫师
uint16_t *magician_b;
//魔法警卫
uint16_t *magic_sergeant;
//史莱姆王
uint16_t *slime_lord;
//吸血蝙蝠
uint16_t *vampire_bat;
//dragon 龙
uint16_t *dragon_wn;
uint16_t *dragon_n;
uint16_t *dragon_en;
uint16_t *dragon_w;
uint16_t *dragon_m;
uint16_t *dragon_e;
uint16_t *dragon_ws;
uint16_t *dragon_s;
uint16_t *dragon_es;
//octopus 章鱼
uint16_t *octopus_wn;
uint16_t *octopus_n;
uint16_t *octopus_en;
uint16_t *octopus_w;
uint16_t *octopus_m;
uint16_t *octopus_e;
uint16_t *octopus_ws;
uint16_t *octopus_s;
uint16_t *octopus_es;
//大魔导师
uint16_t *great_magic_master;
//魔王
uint16_t *boss;
//.............. 特殊物品
//冰冻水晶
uint16_t *snow_crystal;
//幸运金币
uint16_t *lucky_gold;
//十字架
uint16_t *cross;
//传送道具
uint16_t *orbof_flying;
//屠龙匕首
uint16_t *dragon_slayer;
//向上飞行器
uint16_t *wings_to_flyup;
//向下飞行器
uint16_t *wings_to_flydown;
//中心对称飞行器
uint16_t *warp_staff;
//破墙镐
uint16_t *mattock;
//魔法钥匙
uint16_t *magic_key;
//炸药
uint16_t *bomb;
//............. npc
//公主
uint16_t *princess;
//指引者
uint16_t *oldman;
//小偷
uint16_t *thief;
//商人
uint16_t *merchant;
//.......... 剑的分类
//铁剑
uint16_t *iron_sword;
//神圣剑
uint16_t *sacred_sword;
//圣剑
uint16_t *holy_sword;
//骑士剑
uint16_t *knight_sword;
//银剑
uint16_t *silver_sword;
//......... 盾的分类
uint16_t *iron_shield;
uint16_t *sacred_shield;
uint16_t *holy_shield;
uint16_t *knight_shield;
uint16_t *silver_shield;
//............ 背景
//铁门 or 笼子
uint16_t *iron_gate;
//钢门 or 花门
uint16_t *steel_gate;
//熔岩
uint16_t *lava;
//星空
uint16_t *star;
uint16_t *road;
uint16_t *wall;
uint16_t *upstair;
uint16_t *downstair;
uint16_t *yellow_door;
uint16_t *red_door;
uint16_t *blue_door;
uint16_t *yellow_key;
uint16_t *red_key;
uint16_t *blue_key;
uint16_t *yellow_keyy;
uint16_t *red_keyy;
uint16_t *blue_keyy;
uint16_t *attack;
uint16_t *defend;
uint16_t *life;
uint16_t *gold;
//物品
uint16_t *red_crystal;
uint16_t *blue_crystal;
uint16_t *red_elixir;
uint16_t *blue_elixir;
//人物CRYSTAL
uint16_t *people_up;
uint16_t *people_down;
uint16_t *people_right;
uint16_t *people_left;
//enemy
uint16_t *background;
uint16_t *backgroundd;
//uint16_t * MOTA "/motaa.jpg"
//uint16_t * ZHUANGBEI "/zhuangbeii.jpg"
//uint16_t * III "/iii.jpg"
GFXfont *f = NULL;
Warrior w;
void logMemoryy() {
log_d("Used PSRAM: %d", ESP.getPsramSize());
}
void logMemory() {
log_d("Used PSRAM: %d", ESP.getPsramSize() - ESP.getFreePsram());
}
//void initpsarm(char *file, uint16_t *buffer);
void display_picture(int h, int w, uint16_t *data) {
for (int i = 0; i < 20; i++) {
gfx->draw16bitRGBBitmap(w, i + h, data + (i * 20), 20, 1);
}
}
void display_picture2(int h, int w, uint16_t *data) {
for (int i = 0; i < 20; i++) {
gfx->draw16bitRGBBitmap(w, i + h, data + (i * 10), 10, 1);
}
}
void findrole(int& prow, int& pcol)
{
for (prow = 1; prow <= NUM; prow++)
{
for (pcol = 1; pcol <= NUM; pcol++)
{
switch (mappp[w.getLevel()][prow][pcol])
{
case 16:
case 17:
case 18:
case 19: return;
}
}
}
}
void setup() {
Serial.begin(115200);
// Serial.setDebugOutput(true);
// while(!Serial);
Serial.println("PNG Image Viewer");
#ifdef GFX_EXTRA_PRE_INIT
GFX_EXTRA_PRE_INIT();
#endif
// Init Display
gfx->begin();
gfx->fillScreen(BLACK);
gfx->setUTF8Print(true);
#ifdef GFX_BL
pinMode(GFX_BL, OUTPUT);
//digitalWrite(GFX_BL, HIGH);
analogWrite(GFX_BL, 180);
#endif
// pinMode(SDMMC_D3 /* CS /, OUTPUT);
// digitalWrite(SDMMC_D3 / CS */, HIGH);
//#if defined(SOC_SDMMC_USE_GPIO_MATRIX)
// SD_MMC.setPins(SDMMC_CLK, SDMMC_CMD, SDMMC_D0);
//#endif
#if defined(SOC_SDMMC_USE_GPIO_MATRIX)
SD_MMC.setPins(SDMMC_CLK, SDMMC_CMD, SDMMC_D0, SDMMC_D1, SDMMC_D2, SDMMC_D3);
#endif
if (!SD_MMC.begin("/root", true)) {
//if(!FFat.begin(true)){
Serial.println("FFat Mount Failed");
return;
} else {
if (psramInit()) {
Serial.printf("Total PSRAM: %d", ESP.getPsramSize());
Serial.println("\nPSRAM is correctly initialized");
}
}
//rc = png.open(PNG_FILENAME, myOpen, myClose, myRead, mySeek, PNGDraw);
}
void loop() {
logMemoryy();
//给所有的图片素材申请空间
shop_m = (uint16_t *)ps_malloc(800);
shop_l = (uint16_t *)ps_malloc(800);
shop_r = (uint16_t *)ps_malloc(800);
//@@@@@@@@@@@ 敌人
//1
gate_keeper_c = (uint16_t *)ps_malloc(800);
green_slime = (uint16_t *)ps_malloc(800);
red_slime = (uint16_t *)ps_malloc(800);
bat = (uint16_t *)ps_malloc(800);
priest = (uint16_t *)ps_malloc(800);
skeleton_a = (uint16_t *)ps_malloc(800);
skeleton_b = (uint16_t *)ps_malloc(800);
skeleton_c = (uint16_t *)ps_malloc(800);
//2
big_slime = (uint16_t *)ps_malloc(800);
big_bat = (uint16_t *)ps_malloc(800);
rock = (uint16_t *)ps_malloc(800);
super_priest = (uint16_t *)ps_malloc(800);
vampire = (uint16_t *)ps_malloc(800);
zombine_knight = (uint16_t *)ps_malloc(800);
zombine = (uint16_t *)ps_malloc(800);
//3
gate_keeper_b = (uint16_t *)ps_malloc(800);
ghost_solider = (uint16_t *)ps_malloc(800);
gold_knight = (uint16_t *)ps_malloc(800);
knight = (uint16_t *)ps_malloc(800);
slime_man = (uint16_t *)ps_malloc(800);
solider = (uint16_t *)ps_malloc(800);
swords_man = (uint16_t *)ps_malloc(800);
//5
dark_knight = (uint16_t *)ps_malloc(800);
gate_keeper_a = (uint16_t *)ps_malloc(800);
magician_a = (uint16_t *)ps_malloc(800);
magician_b = (uint16_t *)ps_malloc(800);
magic_sergeant = (uint16_t *)ps_malloc(800);
slime_lord = (uint16_t *)ps_malloc(800);
vampire_bat = (uint16_t *)ps_malloc(800);
//dragon 龙
dragon_wn = (uint16_t *)ps_malloc(800);
dragon_n = (uint16_t *)ps_malloc(800);
dragon_en = (uint16_t *)ps_malloc(800);
dragon_w = (uint16_t *)ps_malloc(800);
dragon_m = (uint16_t *)ps_malloc(800);
dragon_e = (uint16_t *)ps_malloc(800);
dragon_ws = (uint16_t *)ps_malloc(800);
dragon_s = (uint16_t *)ps_malloc(800);
dragon_es = (uint16_t *)ps_malloc(800);
//octopus 章鱼
octopus_wn = (uint16_t *)ps_malloc(800);
octopus_n = (uint16_t *)ps_malloc(800);
octopus_en = (uint16_t *)ps_malloc(800);
octopus_w = (uint16_t *)ps_malloc(800);
octopus_m = (uint16_t *)ps_malloc(800);
octopus_e = (uint16_t *)ps_malloc(800);
octopus_ws = (uint16_t *)ps_malloc(800);
octopus_s = (uint16_t *)ps_malloc(800);
octopus_es = (uint16_t *)ps_malloc(800);
//大魔导师
great_magic_master = (uint16_t *)ps_malloc(800);
//魔王
boss = (uint16_t *)ps_malloc(800);
//.............. 特殊物品
snow_crystal = (uint16_t *)ps_malloc(800);
//幸运金币
lucky_gold = (uint16_t *)ps_malloc(800);
//十字架
cross = (uint16_t *)ps_malloc(800);
//传送道具
orbof_flying = (uint16_t *)ps_malloc(800);
dragon_slayer = (uint16_t *)ps_malloc(800);
wings_to_flyup = (uint16_t *)ps_malloc(800);
wings_to_flydown = (uint16_t *)ps_malloc(800);
warp_staff = (uint16_t *)ps_malloc(800);
//破墙镐
mattock = (uint16_t *)ps_malloc(800);
magic_key = (uint16_t *)ps_malloc(800);
bomb = (uint16_t *)ps_malloc(800);
//............. npc
princess = (uint16_t *)ps_malloc(800);
oldman = (uint16_t *)ps_malloc(800);
thief = (uint16_t *)ps_malloc(800);
merchant = (uint16_t *)ps_malloc(800);
//.......... 剑的分类
iron_sword = (uint16_t *)ps_malloc(800);
//神圣剑
sacred_sword = (uint16_t *)ps_malloc(800);
//圣剑
holy_sword = (uint16_t *)ps_malloc(800);
knight_sword = (uint16_t *)ps_malloc(800);
silver_sword = (uint16_t *)ps_malloc(800);
//......... 盾的分类
iron_shield = (uint16_t *)ps_malloc(800);
sacred_shield = (uint16_t *)ps_malloc(800);
holy_shield = (uint16_t *)ps_malloc(800);
knight_shield = (uint16_t *)ps_malloc(800);
silver_shield = (uint16_t *)ps_malloc(800);
//............ 背景
//铁门 or 笼子
iron_gate = (uint16_t *)ps_malloc(800);
//钢门 or 花门
steel_gate = (uint16_t *)ps_malloc(800);
//熔岩
lava = (uint16_t *)ps_malloc(800);
star = (uint16_t *)ps_malloc(800);
road = (uint16_t *)ps_malloc(800);
wall = (uint16_t *)ps_malloc(800);
upstair = (uint16_t *)ps_malloc(800);
downstair = (uint16_t *)ps_malloc(800);
yellow_door = (uint16_t *)ps_malloc(800);
red_door = (uint16_t *)ps_malloc(800);
blue_door = (uint16_t *)ps_malloc(800);
yellow_key = (uint16_t *)ps_malloc(800);
red_key = (uint16_t *)ps_malloc(800);
blue_key = (uint16_t *)ps_malloc(800);
yellow_keyy = (uint16_t *)ps_malloc(800);
red_keyy = (uint16_t *)ps_malloc(800);
blue_keyy = (uint16_t *)ps_malloc(800);
attack = (uint16_t *)ps_malloc(800);
defend = (uint16_t *)ps_malloc(800);
life = (uint16_t *)ps_malloc(800);
gold = (uint16_t *)ps_malloc(800);
//物品
red_crystal = (uint16_t *)ps_malloc(800);
blue_crystal = (uint16_t *)ps_malloc(800);
red_elixir = (uint16_t *)ps_malloc(800);
blue_elixir = (uint16_t *)ps_malloc(800);
//人物
people_up = (uint16_t *)ps_malloc(800);
people_down = (uint16_t *)ps_malloc(800);
people_right = (uint16_t *)ps_malloc(800);
people_left = (uint16_t )ps_malloc(800);
//2020
background = (uint16_t )ps_malloc(800);
//1020
backgroundd = (uint16_t *)ps_malloc(800);
//buffer = (uint16_t *)heap_caps_malloc(80000, MALLOC_CAP_SPIRAM);
//Serial.printf("@@@@@@ %d %f\n", sizeof(uint16_t), sizeof(byte));
//big_bat = (uint16_t *)ps_malloc(400);
logMemory();
// loadpsarm(SHOP_M, shop_m);
//loadpsarm(SHOP_L,shop_l);
//loadpsarm(SHOP_R,shop_r);
/*
//@@@@@@@@@@ 敌人
//1
loadpsarm(gate_keeper_a,gate_keeper_c;
//绿史莱姆
uint16_t *green_slime;
//红史莱姆
uint16_t *red_slime;
//蝙蝠
uint16_t *bat;
//法师
uint16_t *priest;
//骷髅队长
uint16_t *skeleton_a;
//骷髅士兵
uint16_t *skeleton_b;
//骷髅人
uint16_t *skeleton_c;
*/
loadpsarm(SHOP_M, shop_m);
loadpsarm(SHOP_L, shop_l);
loadpsarm(SHOP_R, shop_r);
//1
loadpsarm(GATE_KEEPER_C, gate_keeper_c);
loadpsarm(GREEN_SLIME, green_slime);
loadpsarm(RED_SLIME, red_slime);
loadpsarm(BAT, bat);
loadpsarm(PRIEST, priest);
loadpsarm(SKELETON_A, skeleton_a);
loadpsarm(SKELETON_B, skeleton_b);
loadpsarm(SKELETON_C, skeleton_c);
//2
loadpsarm(BIG_SLIME, big_slime);
loadpsarm(BIG_BAT, big_bat);
loadpsarm(ROCK, rock);
loadpsarm(SUPER_PRIEST, super_priest);
loadpsarm(VAMPIRE, vampire);
loadpsarm(ZOMBINE, zombine);
loadpsarm(ZOMBINE_KNIGHT, zombine_knight);
//3
loadpsarm(GATE_KEEPER_B, gate_keeper_b);
loadpsarm(GHOST_SOLIDER, ghost_solider);
loadpsarm(GOLD_KNIGHT, gold_knight);
loadpsarm(KNIGHT, knight);
loadpsarm(SLIME_MAN, slime_man);
loadpsarm(SOLIDER, solider);
loadpsarm(SWORDS_MAN, swords_man);
//5
loadpsarm(DARK_KNIGHT, dark_knight);
loadpsarm(GATE_KEEPER_A, gate_keeper_a);
loadpsarm(MAGICIAN_A, magician_a);
loadpsarm(MAGICIAN_B, magician_b);
loadpsarm(MAGIC_SERGEANT, magic_sergeant);
loadpsarm(SLIME_LORD, slime_lord);
loadpsarm(VAMPIRE_BAT, vampire_bat);
//dragon
loadpsarm(DRAGON_WN, dragon_wn);
loadpsarm(DRAGON_N, dragon_n);
loadpsarm(DRAGON_EN, dragon_en);
loadpsarm(DRAGON_W, dragon_w);
loadpsarm(DRAGON_M, dragon_m);
loadpsarm(DRAGON_E, dragon_e);
loadpsarm(DRAGON_WS, dragon_ws);
loadpsarm(DRAGON_S, dragon_s);
loadpsarm(DRAGON_ES, dragon_es);
//octopus
loadpsarm(OCTOPUS_WN, octopus_wn);
loadpsarm(OCTOPUS_N, octopus_n);
loadpsarm(OCTOPUS_EN, octopus_en);
loadpsarm(OCTOPUS_W, octopus_w);
loadpsarm(OCTOPUS_M, octopus_m);
loadpsarm(OCTOPUS_E, octopus_e);
loadpsarm(OCTOPUS_WS, octopus_ws);
loadpsarm(OCTOPUS_S, octopus_s);
loadpsarm(OCTOPUS_ES, octopus_es);
//
loadpsarm(GREAT_MAGIC_MASTER, great_magic_master);
loadpsarm(BOSS, boss);
//.............. 特殊物品
//冰冻水晶
loadpsarm(SNOW_CRYSTAL, snow_crystal);
loadpsarm(LUCKY_GOLD, lucky_gold);
loadpsarm(CROSS, cross);
loadpsarm(ORBOFFLY, orbof_flying);
//屠龙匕首
loadpsarm(DRAGON_SLAYER, dragon_slayer);
//向上飞行器
loadpsarm(WINGS_TO_FLYUP, wings_to_flyup);
//向下飞行器
loadpsarm(WINGS_TO_FLYDOWN, wings_to_flydown);
//中心对称飞行器
loadpsarm(WARP_STAFF, warp_staff);
//破墙镐
loadpsarm(MATTOCK, mattock);
//魔法钥匙
loadpsarm(MAGIC_KEY, magic_key);
//炸药
loadpsarm(BOMB, bomb);
//............. npc
//公主
loadpsarm(PRINCESS, princess);
loadpsarm(OLDMAN, oldman);
loadpsarm(THIEF, thief);
loadpsarm(MERCHANT, merchant);
loadpsarm(IRON_SWORD, iron_sword);
loadpsarm(SACRED_SWORD, sacred_sword);
loadpsarm(HOLY_SWORD, holy_sword);
loadpsarm(KNIGHT_SWORD, knight_sword);
loadpsarm(SILVER_SWORD, silver_sword);
loadpsarm(IRON_SHIELD, iron_shield);
loadpsarm(SACRED_SHIELD, sacred_shield);
loadpsarm(HOLY_SHIELD, holy_shield);
loadpsarm(KNIGHT_SHIELD, knight_shield);
loadpsarm(SILVER_SHIELDD, silver_shield);
loadpsarm(IRONGATE, iron_gate);
loadpsarm(STEEL_GATE, steel_gate);
loadpsarm(LAVA, lava);
loadpsarm(STAR, star);
//
loadpsarm(ROAD, road);
loadpsarm(WALL, wall);
loadpsarm(UPSTAIR, upstair);
loadpsarm(DOWNSTAIR, downstair);
loadpsarm(YELLOWDOOR, yellow_door);
loadpsarm(REDDOOR, red_door);
loadpsarm(BLUEDOOR, blue_door);
loadpsarm(YELLOWKEY, yellow_key);
loadpsarm(REDKEY, red_key);
loadpsarm(BLUEKEY, blue_key);
loadpsarm(YELLOWKEYY, yellow_keyy);
loadpsarm(REDKEYY, red_keyy);
loadpsarm(BLUEKEYY, blue_keyy);
loadpsarm(ATTACK, attack);
loadpsarm(DEFEND, defend);
loadpsarm(LIFE, life);
loadpsarm(GOLD, gold);
//物品
loadpsarm(REDCRYSTAL, red_crystal);
loadpsarm(BLUECRYSTAL, blue_crystal);
loadpsarm(REDELIXIR, red_elixir);
loadpsarm(BLUEELIXIR, blue_elixir);
loadpsarm(PEOPLEUP, people_up);
loadpsarm(PEOPLEDOWN, people_down);
loadpsarm(PEOPLERIGHT, people_right);
loadpsarm(PEOPLELEFT, people_left);
loadpsarm(BACKGROUND, background);
loadpsarm(BACKGROUNDD, backgroundd);
//gfx->fillScreen(BLACK);
unsigned long start = millis();
//gfx->fillScreen(RED);
initfirstfloor();
information();
Serial.printf(" time used: %lu\n", millis() - start);
/*
gfx->fillScreen(BLACK);
for (int x = 0; x < 11; x += 20) {
for (int y = 0; y < 1; y += 20) {
display_picture(x, y, wall);
}
}
//for (int i=0;i<30;i++) {
// gfx->draw16bitRGBBitmap(30, i, buffer+(i*30), 30, 1);
// }
Serial.printf(" time used: %lu\n", millis() - start);
*/
delay(100000000);
}
void loadpsarm(char *file, uint16_t *buffer) {
File bmpFile = SD_MMC.open(file, "r");
if (!bmpFile || bmpFile.isDirectory()) {
Serial.println("ERROR: Failed to open file for reading");
} else {
byte lo, hi;
uint16_t tem;
if (strcmp(BACKGROUNDD, file) == 0) {
for (int y = 0; y < 20; y++) {
bmpFile.seek(4 + (y * 20)); //seek at start of line
for (int x = 0; x < 10; x++) {
lo = bmpFile.read();
hi = bmpFile.read();
tem = lo;
tem = tem << 8;
tem = tem | hi;
//Serial.printf(" %d %d %x %x %x\n", y, x, lo, hi, tem);
buffer[y * 10 + x] = tem;
}
}
} else {
for (int y = 0; y < 20; y++) {
bmpFile.seek(4 + (y * 40)); //seek at start of line
for (int x = 0; x < 20; x++) {
lo = bmpFile.read();
hi = bmpFile.read();
tem = lo;
tem = tem << 8;
tem = tem | hi;
//Serial.printf(" %d %d %x %x %x\n", y, x, lo, hi, tem);
buffer[y * 20 + x] = tem;
}
}
}
}
bmpFile.close();
}
void drawmap(int floor)
{
for (int x = 1; x < 12; x++) {
for (int y = 0; y < 13; y++) {
int tem = mappp[floor][x][y];
switch (tem) {
case 0:
if (y == 0) {
display_picture2((x - 1) * 20, y * 20, backgroundd);
}
else if (y == 12) {
display_picture2((x - 1) * 20, (y * 20) - 10, backgroundd);
}
else {
display_picture((x - 1) * 20, (y * 20) - 10, wall);
}
break;
case 1:
display_picture((x - 1) * 20, (y * 20) - 10, road);
break;
//暗墙
case 2:
display_picture((x - 1) * 20, (y * 20) - 10, wall);
break;
//隐形墙
case 3:
display_picture((x - 1) * 20, (y * 20) - 10, road);
break;
//岩浆
case 4:
display_picture((x - 1) * 20, (y * 20) - 10, lava);
break;
//虚空
case 5:
display_picture((x - 1) * 20, (y * 20) - 10, star);
break;
case 6:
display_picture((x - 1) * 20, (y * 20) - 10, yellow_door);
break;
case 7:
display_picture((x - 1) * 20, (y * 20) - 10, blue_door);
break;
case 8:
display_picture((x - 1) * 20, (y * 20) - 10, red_door);
break;
case 9:
display_picture((x - 1) * 20, (y * 20) - 10, iron_gate);
break;
case 10:
display_picture((x - 1) * 20, (y * 20) - 10, steel_gate);
break;
case 11:
display_picture((x - 1) * 20, (y * 20) - 10, upstair);
break;
case 12:
display_picture((x - 1) * 20, (y * 20) - 10, downstair);
break;
case 16:
display_picture((x - 1) * 20, (y * 20) - 10, people_up);
break;
case 17:
display_picture((x - 1) * 20, (y * 20) - 10, people_down);
break;
case 18:
display_picture((x - 1) * 20, (y * 20) - 10, people_left);
break;
case 19:
display_picture((x - 1) * 20, (y * 20) - 10, people_right);
break;
case 21:
display_picture((x - 1) * 20, (y * 20) - 10, yellow_key);
break;
case 22:
display_picture((x - 1) * 20, (y * 20) - 10, blue_key);
case 23:
display_picture((x - 1) * 20, (y * 20) - 10, red_key);
break;
case 24:
display_picture((x - 1) * 20, (y * 20) - 10, red_crystal);
break;
case 25:
display_picture((x - 1) * 20, (y * 20) - 10, blue_crystal);
break;
case 26:
display_picture((x - 1) * 20, (y * 20) - 10, red_elixir);
break;
case 27:
display_picture((x - 1) * 20, (y * 20) - 10, blue_elixir);
break;
case 31:
display_picture((x - 1) * 20, (y * 20) - 10, iron_sword);
break;
case 32:
display_picture((x - 1) * 20, (y * 20) - 10, iron_shield);
break;
case 33:
display_picture((x - 1) * 20, (y * 20) - 10, silver_sword);
break;
case 34:
display_picture((x - 1) * 20, (y * 20) - 10, silver_shield);
break;
case 35:
display_picture((x - 1) * 20, (y * 20) - 10, knight_sword);
break;
case 36:
display_picture((x - 1) * 20, (y * 20) - 10, knight_shield);
break;
case 37:
display_picture((x - 1) * 20, (y * 20) - 10, sacred_sword);
break;
case 38:
display_picture((x - 1) * 20, (y * 20) - 10, sacred_shield);
break;
case 39:
display_picture((x - 1) * 20, (y * 20) - 10, holy_sword);
break;
case 40:
display_picture((x - 1) * 20, (y * 20) - 10, holy_shield);
break;
case 41:
display_picture((x - 1) * 20, (y * 20) - 10, orbof_flying);
break;
//notebook
case 42:
display_picture((x - 1) * 20, (y * 20) - 10, orbof_flying);
break;
case 43:
display_picture((x - 1) * 20, (y * 20) - 10, cross);
break;
case 44:
display_picture((x - 1) * 20, (y * 20) - 10, mattock);
break;
case 45:
display_picture((x - 1) * 20, (y * 20) - 10, bomb);
break;
case 46:
display_picture((x - 1) * 20, (y * 20) - 10, warp_staff);
break;
case 47:
display_picture((x - 1) * 20, (y * 20) - 10, lucky_gold);
break;
case 48:
display_picture((x - 1) * 20, (y * 20) - 10, snow_crystal);
break;
case 49:
display_picture((x - 1) * 20, (y * 20) - 10, wings_to_flydown);
break;
case 50:
display_picture((x - 1) * 20, (y * 20) - 10, wings_to_flyup);
break;
case 51:
display_picture((x - 1) * 20, (y * 20) - 10, magic_key);
break;
case 52:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_slayer);
break;
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
case 98:
case 99:
case 100:
display_picture((x - 1) * 20, (y * 20) - 10, thief);
break;
case 101:
case 102:
case 103:
case 104:
case 105:
case 106:
case 107:
case 108:
case 109:
case 110:
case 111:
case 112:
case 113:
case 114:
case 115:
case 116:
case 117:
case 118:
case 119:
case 120:
display_picture((x - 1) * 20, (y * 20) - 10, oldman);
break;
case 131:
case 132:
case 133:
case 134:
case 135:
case 136:
case 137:
case 138:
case 139:
case 140:
case 141:
case 142:
display_picture((x - 1) * 20, (y * 20) - 10, merchant);
break;
case 160:
display_picture((x - 1) * 20, (y * 20) - 10, shop_l);
break;
case 161:
display_picture((x - 1) * 20, (y * 20) - 10, shop_m);
break;
case 162:
display_picture((x - 1) * 20, (y * 20) - 10, shop_r);
break;
case 163:
case 164:
display_picture((x - 1) * 20, (y * 20) - 10, princess);
break;
case 251:
display_picture((x - 1) * 20, (y * 20) - 10, green_slime);
break;
case 252:
display_picture((x - 1) * 20, (y * 20) - 10, red_slime);
break;
case 253:
display_picture((x - 1) * 20, (y * 20) - 10, bat);
break;
case 254:
display_picture((x - 1) * 20, (y * 20) - 10, priest);
break;
case 255:
display_picture((x - 1) * 20, (y * 20) - 10, skeleton_c);
break;
case 256:
display_picture((x - 1) * 20, (y * 20) - 10, skeleton_b);
break;
case 257:
display_picture((x - 1) * 20, (y * 20) - 10, gate_keeper_c);
break;
case 258:
display_picture((x - 1) * 20, (y * 20) - 10, skeleton_a);
break;
case 259:
display_picture((x - 1) * 20, (y * 20) - 10, big_slime);
break;
case 260:
display_picture((x - 1) * 20, (y * 20) - 10, big_bat);
break;
case 261:
display_picture((x - 1) * 20, (y * 20) - 10, super_priest);
break;
case 262:
display_picture((x - 1) * 20, (y * 20) - 10, zombine);
break;
case 263:
display_picture((x - 1) * 20, (y * 20) - 10, zombine_knight);
break;
case 264:
display_picture((x - 1) * 20, (y * 20) - 10, rock);
break;
case 265:
display_picture((x - 1) * 20, (y * 20) - 10, vampire);
break;
case 266:
display_picture((x - 1) * 20, (y * 20) - 10, ghost_solider);
break;
case 267:
display_picture((x - 1) * 20, (y * 20) - 10, solider);
break;
case 268:
display_picture((x - 1) * 20, (y * 20) - 10, slime_man);
break;
case 269:
display_picture((x - 1) * 20, (y * 20) - 10, gate_keeper_b);
break;
case 270:
display_picture((x - 1) * 20, (y * 20) - 10, swords_man);
break;
case 271:
display_picture((x - 1) * 20, (y * 20) - 10, knight);
break;
case 272:
display_picture((x - 1) * 20, (y * 20) - 10, gold_knight);
break;
case 282:
display_picture((x - 1) * 20, (y * 20) - 10, great_magic_master);
break;
case 280:
case 281:
case 283:
display_picture((x - 1) * 20, (y * 20) - 10, boss);
break;
case 284:
display_picture((x - 1) * 20, (y * 20) - 10, octopus_wn);
break;
case 285:
display_picture((x - 1) * 20, (y * 20) - 10, octopus_n);
break;
case 286:
display_picture((x - 1) * 20, (y * 20) - 10, octopus_en);
break;
case 287:
display_picture((x - 1) * 20, (y * 20) - 10, octopus_w);
break;
case 288:
display_picture((x - 1) * 20, (y * 20) - 10, octopus_m);
break;
case 289:
display_picture((x - 1) * 20, (y * 20) - 10, octopus_e);
break;
case 290:
display_picture((x - 1) * 20, (y * 20) - 10, octopus_ws);
break;
case 291:
display_picture((x - 1) * 20, (y * 20) - 10, octopus_s);
break;
case 292:
display_picture((x - 1) * 20, (y * 20) - 10, octopus_es);
break;
case 293:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_wn);
break;//魔龙左上
case 294:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_n);
break;//中上
case 295:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_en);
break;//右上
case 296:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_w);
break;
case 297:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_m);
break;
case 298:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_e);
break;
case 299:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_ws);
break;
case 300:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_s);
break;
case 301:
display_picture((x - 1) * 20, (y * 20) - 10, dragon_es);
break;
case 302:
display_picture((x - 1) * 20, (y * 20) - 10, magician_b);
break;
case 303:
display_picture((x - 1) * 20, (y * 20) - 10, magician_a);
break;//高级巫师
case 304:
display_picture((x - 1) * 20, (y * 20) - 10, slime_lord);
break;
case 305:
display_picture((x - 1) * 20, (y * 20) - 10, vampire_bat);
break;//吸血蝙蝠
case 306:
display_picture((x - 1) * 20, (y * 20) - 10, dark_knight);
break;//黑暗骑士
case 307:
display_picture((x - 1) * 20, (y * 20) - 10, magic_sergeant);
break;//魔法警卫
case 308:
display_picture((x - 1) * 20, (y * 20) - 10, gate_keeper_a);
break;//高级卫兵
}
}
}
}
void initfirstfloor() {
for (int x = 1; x < 12; x++) {
for (int y = 0; y < 13; y++) {
int tem = mappp[1][x][y];
switch (tem) {
case 0:
if (y == 0) {
display_picture2((x - 1) * 20, y * 20, backgroundd);
} else if (y == 12) {
display_picture2((x - 1) * 20, (y * 20) - 10, backgroundd);
} else {
display_picture((x - 1) * 20, (y * 20) - 10, wall);
}
break;
case 1:
display_picture((x - 1) * 20, (y * 20) - 10, road);
break;
case 6:
display_picture((x - 1) * 20, (y * 20) - 10, yellow_door);
break;
case 8:
display_picture((x - 1) * 20, (y * 20) - 10, red_door);
break;
case 11:
display_picture((x - 1) * 20, (y * 20) - 10, upstair);
break;
case 17:
display_picture((x - 1) * 20, (y * 20) - 10, people_down);
break;
case 21:
display_picture((x - 1) * 20, (y * 20) - 10, yellow_key);
break;
case 22:
display_picture((x - 1) * 20, (y * 20) - 10, blue_key);
case 23:
display_picture((x - 1) * 20, (y * 20) - 10, red_key);
break;
case 24:
display_picture((x - 1) * 20, (y * 20) - 10, red_crystal);
break;
case 25:
display_picture((x - 1) * 20, (y * 20) - 10, blue_crystal);
break;
case 26:
display_picture((x - 1) * 20, (y * 20) - 10, red_elixir);
break;
case 27:
display_picture((x - 1) * 20, (y * 20) - 10, blue_elixir);
break;
case 41:
display_picture((x - 1) * 20, (y * 20) - 10, orbof_flying);
break;
case 251:
display_picture((x - 1) * 20, (y * 20) - 10, green_slime);
break;
case 252:
display_picture((x - 1) * 20, (y * 20) - 10, red_slime);
break;
case 253:
display_picture((x - 1) * 20, (y * 20) - 10, bat);
break;
case 254:
display_picture((x - 1) * 20, (y * 20) - 10, priest);
break;
case 255:
display_picture((x - 1) * 20, (y * 20) - 10, skeleton_c);
break;
case 256:
display_picture((x - 1) * 20, (y * 20) - 10, skeleton_b);
break;
}
}
}
}
void information() {
for (int x = 0; x < 240; x += 20) {
display_picture(220, x, background);
}
for (int x = 0; x < 130; x += 20) {
display_picture(280, x, background);
}
display_picture(240, 0, life);
display_picture(240, 70, gold);
display_picture(260, 0, attack);
display_picture(260, 70, defend);
display_picture(240, 135, yellow_keyy);
display_picture(260, 135, blue_keyy);
display_picture(280, 135, red_keyy);
displaymota();
displayzhuangbei();
}
void displaymota()
{
gfx->setFont(u8g2_font_unifont_t_chinese);
gfx->setTextColor(WHITE);
gfx->setCursor(188, 265);
gfx->println("魔 塔");
gfx->setCursor(183, 290);
gfx->println("第 层");
//displayfloor();
gfx->setFont(f);
}
void displayzhuangbei()
{
gfx->setFont(u8g2_font_unifont_t_chinese);
gfx->setTextColor(WHITE);
gfx->setCursor(0, 315);
gfx->println("装备");
gfx->setFont(f);
}
new
#include<unordered_map>
#include
#define MAX_NEWS 30001
#define MAX_USER 501
using namespace std;
struct NEW {
int newsId;
int mTime;
int channelId;
};
struct USER
{
int userid;
int newcnt;
int nlist[MAX_NEWS];
};
struct CHANNEL
{
int channelid;
int usercnt;
int userist[MAX_USER];
};
NEW newsList[MAX_NEWS];
USER userList[MAX_USER];
CHANNEL channelList[MAX_USER];
struct cmp {
bool operator()(int a, int b) {
if (newsList[a].mTime != newsList[b].mTime) {
return newsList[a].mTime > newsList[b].mTime;
}
else {
return newsList[a].newsId > newsList[b].newsId;
}
}
};
priority_queue<int, vector, cmp>pq;
//channel id,user id
unordered_map<int, int>channel;
//user id,newid
unordered_map<int, int>umap;
unordered_map<int, int>real;
int cnt;
int sum;
int channelnum;
void update(int mtime)
{
while (!pq.empty() && newsList[pq.top()].mTime <= mtime)
{
int id = pq.top();
pq.pop();
int channelid = newsList[id].channelId;
if (channelid == -1)
continue;
for (register int i=0;i<channelList[channelid].usercnt;i++)
{
int userindex = channelList[channelid].userist[i];
userList[userindex].nlist[userList[userindex].newcnt] = id;
userList[userindex].newcnt++;
}
}
}
void init(int N, int K)
{
cnt = 1;
sum = 1;
channelnum = 1;
pq = {};
channel.clear();
umap.clear();
real.clear();
}
int findchannel(int cid)
{
if (channel.count(cid))
return channel[cid];
channelList[channelnum].channelid = cid;
channelList[channelnum].usercnt = 0;
channel[cid] = channelnum;
channelnum++;
return channel[cid];
}
void registerUser(int mTime, int mUID, int mNum, int mChannelIDs[])
{
update(mTime);
if (umap.count(mUID) == 0)
{
umap[mUID] = sum;
userList[sum].userid = mUID;
userList[sum].newcnt = 0;
sum++;
}
int userid = umap[mUID];
for (register int i = 0; i < mNum; i++)
{
int channelIndex = findchannel(mChannelIDs[i]);
channelList[channelIndex].userist[channelList[channelIndex].usercnt++] = userid;
}
}
int offerNews(int mTime, int mNewsID, int mDelay, int mChannelID)
{
int channelIndex = findchannel(mChannelID);
newsList[cnt].channelId = channelIndex;
newsList[cnt].mTime = mTime + mDelay;
newsList[cnt].newsId = mNewsID;
pq.push(cnt);
umap[mNewsID] = cnt;
cnt++;
return channelList[channelIndex].usercnt;
}
void cancelNews(int mTime, int mNewsID)
{
register int id = umap[mNewsID];
newsList[id].channelId = -1;
}
int checkUser(int mTime, int mUID, int mRetIDs[])
{
update(mTime);
register int ans = 0;
int userid = umap[mUID];
for (register int i = userList[userid].newcnt - 1; i >= 0; i--)
{
int newid = userList[userid].nlist[i];
if (newsList[newid].channelId == -1)
continue;
if (ans < 3)
mRetIDs[ans] = newsList[newid].newsId;
ans++;
}
userList[userid].newcnt = 0;
return ans;
}
Umbrella Warehouse
#define nm 10500
#include
#include <unordered_map>
#include
#include
using namespace std;
vector Conn[nm];
int n;
int Sm[nm];
int Q[nm];
int Dis[nm];
void init(int N, int mParent[], int mDistance[], int mQuantity[])
{
n = N;
for (int i = 0; i < nm; i++) {
Conn[i].clear();
}
for (int i = 0; i < N; i++) {
Conn[i].push_back(mParent[i]);
if (mParent[i] != -1) {
Conn[mParent[i]].push_back(i);
}
Q[i] = mQuantity[i];
Dis[i] = mDistance[i];
}
for (int i = N - 1; i >= 0; i--) {
Sm[i] = mQuantity[i];
for (int j = 1; j < Conn[i].size(); j++) {
Sm[i] += Sm[Conn[i][j]];
}
}
}
int carry(int mFrom, int mTo, int mQuantity)
{
int a1 = mFrom, a2 = mTo;
int sm = 0;
vector A1; vector A2;
while (a1 != a2) {
if (a1 > a2) {
A1.push_back(a1);
sm += Dis[a1];
a1 = Conn[a1][0];
}
else {
A2.push_back(a2);
sm += Dis[a2];
a2 = Conn[a2][0];
}
}
for (auto i : A1) {
Sm[i] -= mQuantity;
}
for (auto i : A2) {
Sm[i] += mQuantity;
}
Q[mFrom] -= mQuantity;
Q[mTo] += mQuantity;
return sm * mQuantity;
}
int gather(int mID, int mQuantity)
{
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
vector notTake(nm, -1);
for (int i : Conn[mID]) {
if (i < 0) continue;
if (i < mID) pq.push({ Dis[mID],i });
else pq.push({ Dis[i], i });
notTake[i] = mID;
}
int totQ = mQuantity;
int ans = 0;
while (totQ != 0) {
int val = pq.top().second;
int prevDis = pq.top().first;
int quan = min(totQ, Q[val]);
totQ -= quan;
ans += carry(val, mID, quan);
pq.pop();
for (int i : Conn[val]) {
if (i != notTake[val] && i != -1) {
if (i < val) pq.push({ prevDis + Dis[val],i });
else pq.push({ prevDis + Dis[i],i });
notTake[i] = val;
}
}
}
return ans;
}
int sum(int mID)
{
return Sm[mID];
}
https://www.gravitech.us/arpromi5v.html
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.