nxt

中规中矩的一场。 题目链接： http://acm.hdu.edu.cn/contests/contest_show.php?cid=855 C： 定义函数f(d,k)为数字d在数字k中出现的次数。给定d和x，找到尽量大的k使得k<=x且f(d,k)==k。 很诡异的一题，最好的做法仍然是打表找规律。题解给了一个很神奇的结论：满足条件的k<10 11 且k的分布非常稀疏。 1 /* basic header */ 2 #include <bits/stdc++.h> 3 /* define */ 4 #define ll long long 5 #define dou double 6 #define pb emplace_back 7 #define mp make_pair 8 #define sot(a,b) sort(a+1,a+1+b) 9 #define rep1(i,a,b) for(int i=a;i<=b;++i) 10 #define rep0(i,a,b) for(int i=a;i<b;++i) 11 #define eps 1e-8 12 #define int_inf 0x3f3f3f3f 13 #define ll_inf 0x7f7f7f7f7f7f7f7f 14 #define lson (curpos<<1) 15 #define rson

目录 @description@ @solution@ @accepted code@ @details@ @description@ 给定一棵无根树，每个节点上都写了一个整数。 你的任务就是统计有多少种方法可以将这棵树分解为若干条路径，使得每个节点恰好属于一条路径，而且每条路径的节点上的数字之和非负。 输入格式 输入数据第一行包含一个整数 T，表示数据组数。 接下来是 T 组数据。 每组数据的第一行包含一个整数 N，代表树中结点个数。 接下来一行包含 N 个整数，由空格分隔，代表每个节点上写的数字。 接下来 N −1 行，每行包含两个整数 Xj 和 Yj，代表编号为 Xj 和 Yj 的节点之间有边直接相连。 输出格式 对于每组数据，输出一行，包含一个整数，即为将树分解的方案数对 10^9 +7 取模得到的结果。 数据范围与子任务 • 1 ≤ T ≤ 10^5 • 1 ≤ Xj,Yj ≤ N 样例数据 输入 1 4 1 10 5 -1 1 2 1 3 2 4 输出 4 样例解释 一共有 4 种分解方法： • 整棵树即为一条路径，其和为 1 + 10 + 5 + (−1) = 15； • 一条路径包含节点 2 和 4，其和为 10 + (−1) = 9；另一条路径包含节点 1 和 3，其和为 1 + 5 = 6； • 一条路径包含节点1、2和4，其和为 1+10+(−1) = 10

class Solution { public: int findTargetSumWays(vector<int>& nums, int S) { int n=nums.size(); if(n==0) return 0; map<int, int>cur; cur[nums[0]]=1; cur[-nums[0]]+=1; map<int, int>nxt; for(int i=1; i<n; i++) { nxt.clear(); for(auto it=cur.begin(); it!=cur.end(); it++) { nxt[it->first+nums[i]]+=cur[it->first]; nxt[it->first-nums[i]]+=cur[it->first]; } cur=nxt; } if(n==1 &&(nums[0]==S || -nums[0]==S)) return 1; return nxt[S]; } }; 来源： https://blog.csdn.net/Scarlett_Guan/article/details/99186948

A. Salty Fish 假设要偷走所有的苹果，那么现在需要放弃一些苹果，并且黑掉一些监控相机以保证能偷走没有放弃的苹果，我们需要最小化放弃的苹果的收益之和加上黑掉相机支付的代价的总和。 考虑最小割建图： 源点$S$向每个监控相机连边，割掉这条边的代价为黑掉它的代价，割掉这条边表示黑掉这个监控相机。 每个节点向汇点$T$连边，割掉这条边的代价为这个点的苹果数，割掉这条边表示放弃这个节点的苹果。 每个监控相机向其监控范围内的所有节点连边，割掉这条边的代价为$+\infty$，表示不能破坏监控关系。 那么每条$S$到$T$的路径都表示某个节点既没有并放弃，又被一些相机监控着，这是不合法的。我们需要割掉代价之和最少的边，使得$S$和$T$不连通，因此最终的答案就是所有节点的苹果数量之和减去这个图的最小割。 因为最小割=最大流，从叶子向根节点依次考虑每棵子树，计算最大流。设$v[i][j]$表示$i$的子树中离$i$距离为$j$的那些节点还能提供多少流量，那么考虑监控范围最高点在$i$的每个监控相机，显然应该优先接收距离较大的那些节点的流量。 用std::map存储每个值非零的$v[i]$，可以在总计$O(m\log n)$的时间内求出最大流。至于$v[i]$的计算，可以由$i$的儿子的$v$启发式合并而来。 注意到这是关于深度的一个启发式合并，如果将这棵树长链剖分，计算出每个点$x

/* set里的一定是本质不同的回文串，所以先建立回文树 当a可以通过nxt指针到达b，或者b可以通过fail指针到达a时，a就是b的子串 对于回文树里的每个结点u，我们可以将和其有关的结点为两部分： 1.结点下方的子树，这部分的所有结点都可以由u在两边加点得到，设大小为 size[u] 2.结点向上的fail链，这条链上的所有结点都是u的回文后缀,设大小为 tot[u] 那么所有fail链上的点都是u的子树的子串，所以u的贡献为size[u]*tot[u] 然后还要去重：对于u的子孙v, v的fail链可能会与u重合，重合部分的贡献在u处已经算过，那么显然v处就不用再算一次 所以dfs时要用vis标记被访问过的fail点，推出递归前回溯即可 */ #include<bits/stdc++.h> using namespace std; #define maxn 100005 struct PAM{ int nxt[maxn][26],len[maxn],fail[maxn]; int num[maxn],cnt[maxn]; int S[maxn],n,p,last; int newnode(int l){ memset(nxt[p],0,sizeof nxt[p]); len[p]=l; num[p]=cnt[p]=0; return p++; } void init(){ p

KMP算法模板 原理 见参考文章 模板 #include <iostream> #include <cstring> #define max_n 100005 using namespace std; char s[max_n] = {'a','a','b','a','a','a','b','c'}; char p[max_n] = {'a','a','a','b'}; int nxt[max_n];//nxt跳转表，nxt[k]表示在k之前有的最大相同前后缀的长度 void get_next(char* p,int nxt[])//构造nxt表 { int pLen=strlen(p); nxt[0] = -1;//nxt表首元素必为-1，表示没元素会和他配对，要重新开始匹配模式串 int k = -1;//初始为-1，重新开始的标志也是-1 int j = 0; while(j<pLen-1) { //p[j]是后缀,p[k]是前缀 if(k=-1||p[j]==p[k])//如果重新匹配或者成功匹配 { ++j; ++k; if(p[j]!=p[k]) { nxt[j] = k; } else nxt[j] = nxt[k];//避免p[j]==p[nxt[j]],所以继续递归，k=nxt[k]=nxt[nxt[k]] } else { k = nxt[k]; } } }

/* 每个状态存最长匹配长度，然后多个串匹配过程中取最小的最长匹配长度 和LCS1不同的地方：LCS只要维护住当前匹配长度和最长匹配长度即可，但是多串匹配需要维护的是每个状态结点(即后缀树上)的信息 所以对每个状态存下两个值Max，Min，分别表示该状态对于该串的最长匹配长度，以及所有已经匹配过的串在该状态下的最小的最长匹配长度 在对一个串进行匹配后，在后缀树上自底向上回溯一次，更新Max值 更新完Max后再更新Min */ #include<bits/stdc++.h> using namespace std; #define maxn 400005 struct SAM{ int last,cnt; int nxt[maxn][26],len[maxn],link[maxn]; SAM(){last=cnt=1;} void add(int c){ int p=last,np=last=++cnt; len[np]=len[p]+1; for(;p&&!nxt[p][c];p=link[p]) nxt[p][c]=np; if(!p){link[np]=1;return;} int q=nxt[p][c]; if(len[q]==len[p]+1){link[np]=q;return;} int clone=++cnt; link[clone]=link[q]; len

I am building a balancing robot using the Lego Mindstorm's NXT system. I am using two sensors from HiTechnic, the first being an Accelerometer and the second being a Gyroscope. I've successfully filtered out noise from both sensors and derived angles for both in a range between -90 and 90 degrees, with 0 degrees being perfectly balanced. My next challenge is to combine both of the sensor values to correct for the Gyroscope's drift over time. Below is an example graph I created from actual data to demonstrate the drift from the gyroscope: The most commonly used approach I've seen to make

经典题 注意匹配的时候：用t串去s串的SAM里进行匹配，和字典树一样遍历t中字符，用cur记录当前已经匹配的长度，如果能当前字符能匹配则cur++(这里不能直接用cur=len[now]),反之用link指针进行失配，直到完成匹配后cur=len[now] 为什么匹配成功时不能直接cur=len[now]?因为自动机上的转移是在后面加一个字符，但是不保证前面不加字符，因为每个结点的len是该节点代表的maxlen 但是失配后再转移成功则可以用cur=len[now],因为失配结点代表的最短串长度都有len[now]+1，即到了这个状态，那么t串一定有minlen[now]的长度,所以其link指向的状态的maxlen[now]=minlen[now-1]一定是满足条件的！ #include<bits/stdc++.h> using namespace std; #define maxn 250005 struct SAM{ int cnt,last; int nxt[maxn<<1][26]; int link[maxn<<1]; int len[maxn<<1]; SAM(){ cnt=last=1; } void insert(int c){ int p=last,np=last=++cnt; len[np]=len[p]+1; for(;p&&!nxt[p][c];p