codeforces每日一题1-10
目录：
1.1093D. Beautiful Graph(DFS染色)
2.514C - Watto and Mechanism(Tire)
3.69E.Subsegments(STL)
4.25C. Roads in Berland(最短路松弛操作)
5.128B. String Problem (floyd预处理)
6.33C.Wonderful Randomized Sum(思维)
7.1292B.Aroma's Search (暴力+思维)
8.1286 A.Garland(DP)
9.1285D Dr. Evil Underscores (01Trie+DFS)
10.631C. Report(单调栈)
11.1119D. Frets On Fire (二分+排序)
12.1234D. Distinct Characters Queries(STL/线段树)
13.1073C. Vasya and Robot(二分+前缀和)
14.455A. Boredom(DP+map)
15.225C. Barcode(DP)
1093D. Beautiful Graph(DFS染色)
题意：
给你一个一个n个顶点，m条边的无向图，你可以将顶点赋值为1,2,3，现在问你有多少种赋值方案，使得任意一条边的两个顶点权值和为奇数
思路：
由于权值和要为奇数，所有一条边的两个顶点要一个为奇数，一个为偶数，所以就变成了一个染色问题
要注意图并不一定联通，所以答案为每个连通块内(2^(奇数)+2^(偶数))的乘积和-可以由组合数进行推导
如果有任意一个块无法染色，则答案为0
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
const ll mod=;
const int maxn=3e5+;
vector<int> a[maxn];
int num1,num2,color[maxn],n=,flag,two[maxn];
void pre_process()
{
two[]=;
for(int i=;i<maxn;i++)
two[i]=(*two[i-])%mod;
}
void dfs(int x,int fa,int co)
{
if(!flag) return;
color[x]=co;
if(co==) num1++;
else num2++;
for(int i=;i<a[x].size();i++){
int to=a[x][i];
if(color[to]==color[x])
{
flag=;return ;
}
if(to!=fa&&color[to]==)
{
if(co==) dfs(to,x,);
else dfs(to,x,);
}
}
}
int main()
{
int t,m,u,v;
ll ans=;
scanf("%d",&t);
pre_process();
while(t--){
for(int i=;i<=n;i++) a[i].clear(),color[i]=;
num1,num2,ans=;
flag=;
scanf("%d%d",&n,&m);
for(int i=;i<=m;i++){
scanf("%d%d",&u,&v);
a[u].push_back(v);
a[v].push_back(u);
}
for(int i=;i<=n;i++){
if(!flag) break;
if(!color[i]){
num1=num2=;
dfs(i,-,);
ans*=(two[num1]+two[num2])%mod;
ans%=mod;
}
}
if(!flag) cout<<<<endl;
else cout<<ans%mod<<endl;
}
return ;
}
514C - Watto and Mechanism(Tire)
题意：
给n个模式串，m个匹配串，问是否有只与匹配串相差一个字符的模式串
思路：
直接上Tire，正常插入模式串
匹配时往该节点的儿子节点进行正常匹配，若能匹配成功，就输出YES
#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
using namespace std;
const int maxn=1e6+;
int n,m;
struct Tire{
int ch[maxn][],val[maxn],cnt;
void init()
{
cnt=;
memset(ch,,sizeof(ch));
val[]=;
}
void insert(string s){
int u=,n=s.length();
for(int i=;i<n;i++){
int c=s[i]-'a';
if(!ch[u][c]) ch[u][c]=cnt++;
u=ch[u][c];
}
val[u]=cnt;
}
bool query(string s){
int u=,n=s.length(),flag,k;
for(int i=;i<n;i++){
int c=s[i]-'a';
for(int j=;j<=;j++){
if(c==j||ch[u][j]==) continue;
int x=ch[u][j];
flag=;
for(int k=i+;k<n;k++){
int y=s[k]-'a';
if(!ch[x][y]){
flag=;
break;
}
x=ch[x][y];
}
if(flag&&val[x]) return true;
}
if(!ch[u][c]) return false;
u=ch[u][c];
}
return false;
}
}T;
int main()
{
string temp;
scanf("%d%d",&n,&m);
T.init();
for(int i=;i<=n;i++){
cin>>temp;
T.insert(temp);
}
for(int i=;i<=m;i++){
cin>>temp;
if(T.query(temp)) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return ;
}
69E.Subsegments(STL)
题意：
输出每一个长度为K的区间中出现次数不为1数的最大值
思路：
维护一个map与set
set用于维护当前所指向的区间(可以O(logn)直接取到最大值与删除容器内元素)
map用于维护区间内元素的出现个数
先将前k个元素加入set内，每个元素加入之后，通过map查询其出现次数，如果不为1则抹去，最后判断set是否为空，如果不为空则输出set内的最后一个元素(set容器内元素有序)
之后移动区间，需要删去一个元素这里要注意如果元素删去后其出现次数为1的话，要将其重新加入区间内
#include<iostream>
#include<algorithm>
#include<map>
#include<set>
using namespace std;
const int maxn=1e5+;
map<int,int> cnt;
set<int> s;
int a[maxn];
int main()
{
int n,k;
scanf("%d%d",&n,&k);
for(int i=;i<=n;i++) scanf("%d",&a[i]);
for(int i=;i<=k;i++){
cnt[a[i]]++;
if(cnt[a[i]]!=) s.erase(a[i]);
else s.insert(a[i]);
}
if(s.empty()) cout<<"Nothing"<<endl;
else cout<<*(--s.end())<<endl;
for(int i=k+;i<=n;i++){
cnt[a[i]]++;
cnt[a[i-k]]--;
if(cnt[a[i]]!=) s.erase(a[i]);
else s.insert(a[i]);
if(cnt[a[i-k]]==) s.insert(a[i-k]);
else s.erase(a[i-k]);
if(s.empty()) cout<<"Nothing"<<endl;
else cout<<*(--s.end())<<endl;
}
return ;
}
25C. Roads in Berland(最短路松弛操作)
题意：
给你一个dis[i][j]矩阵，代表从i顶点到j顶点的最短路，再给你k条路，每次将其加入地图中，问加入后各个顶点之间最短路的和
思路：
如果加入的道路距离比原来的距离长，则不需要修改答案
如果小于原来的距离，则先将原来的距离更新，枚举起点与重点判断能否进行松弛操作
松弛操作：①dis[i][j]>dis[i][v]+w+dis[u][j]
②dis[i][j]>dis[i][u]+w+dis[v][j]
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
const int maxn=;
ll dis[maxn][maxn];
ll n,ans=,m,u,v,w;
void solve()
{
for(int i=;i<=n;i++){
for(int j=;j<=n;j++){
if(dis[i][j]>dis[i][v]+w+dis[u][j]){
ans-=dis[i][j]-(dis[i][v]+w+dis[u][j]);
dis[i][j]=dis[j][i]=dis[i][v]+w+dis[u][j];
}
if(dis[i][j]>dis[i][u]+w+dis[v][j]){
ans-=dis[i][j]-(dis[i][u]+w+dis[v][j]);
dis[i][j]=dis[j][i]=dis[i][u]+w+dis[v][j];
}
}
}
}
int main()
{
scanf("%lld",&n);
for(int i=;i<=n;i++)
for(int j=;j<=n;j++){
scanf("%lld",&dis[i][j]);
ans+=dis[i][j];
}
ans/=;
scanf("%lld",&m);
for(int i=;i<=m;i++){
scanf("%lld%lld%lld",&u,&v,&w);
if(dis[u][v]<=w){
cout<<ans<<" ";
continue;
}
else{
ans-=dis[u][v]-w;
dis[u][v]=dis[v][u]=w;
solve();
cout<<ans<<" ";
}
}
return ;
}
128B. String Problem (floyd预处理)
题意：
给两个字符串，以及m个从字符a变换到b的代价，问把两个字符串变得相同的最小代价
思路：
将字符串变换的代价当做一条有向边建图，之后跑floyd，得到从字符i变成j的最小代价dis[i][j]
之后遍历两个字符串的每一位，不相同的话枚举变成什么字符所需要的代价最小，如果找不到这样一个中间点使得s1[i]=ch,s2[i]=ch,则直接输出-1，最后将最小代价累加就好了
#include<iostream>
#include<algorithm>
#include<cstring>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=1e5+;
int dis[][],mp[][];
char s1[maxn],s2[maxn],a1,a2,s3[maxn];
void floyd()
{
for(int i=;i<;i++)
for(int j=;j<;j++) dis[i][j]=mp[i][j];
for(int k=;k<;k++)
for(int i=;i<;i++)
for(int j=;j<;j++)
dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
}
int main()
{
int n,w;
cin>>s1>>s2>>n;
for(int i=;i<;i++)
for(int j=;j<;j++){
if(i==j) mp[i][j]=;
else mp[i][j]=inf;
}
for(int i=;i<=n;i++){
cin>>a1>>a2>>w;
int u=a1-'a',v=a2-'a';
mp[u][v]=min(mp[u][v],w);
}
floyd();
int len1=strlen(s1),len2=strlen(s2);
if(len1!=len2){
cout<<-<<endl;
return ;
}
int ans=;
for(int i=;i<len1;i++){
if(s1[i]==s2[i]){s3[i]=s1[i];continue;}
else{
int mini=inf,x=-,u=s1[i]-'a',v=s2[i]-'a';
for(int j=;j<;j++){
if(dis[u][j]+dis[v][j]<mini) mini=dis[u][j]+dis[v][j],x=j;
}
if(x==-){
cout<<"-1"<<endl;
return ;
}
else{
s3[i]=x+'a';
ans+=mini;
}
}
}
cout<<ans<<endl<<s3<<endl;
return ;
}
33C.Wonderful Randomized Sum
题意：
给一个数组你可以把一段前缀和乘上-1，再把一个后缀和乘上-1，前缀跟后缀之间可以有重叠部分，问操作后序列的最大和是多少
思路:
我们先考虑有重叠的部分，由于乘了两次-1，所有重合的部分不变，因此答案的方案肯定不会有重叠部分
我们假设所有元素的和为sum，从反面思考假设中间的那段和为s，那么操作后数组的和为-(sum - s) + s = 2 * s - sum
所以问题就转化为找一个最大子序列问题了
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1e5+;
int a[maxn];
int main()
{
int n,sum=;
scanf("%d",&n);
for(int i=;i<=n;i++){
scanf("%d",&a[i]);
sum+=a[i];
}
int mx,cnt=;
for(int i=;i<=n;i++){
cnt+=a[i];
if(cnt<) cnt=;
mx=max(mx,cnt);
}
cout<<*mx-sum<<endl;
return ;
}
1292B.Aroma's Search (暴力+思维)
题意：
告诉一个点的位置，之后的点按照x[i]=x[i-1]*ax+bx;，y[i]=y[i-1]*ay+by的规律分布，初始时你站在一个位置，每秒可以往四个方向移动，问你在t内最多能走过多少个点
思路：
通过数据我们可以发现，在264就已经超过了1e16也就是t的范围了，因此地图内最多只有64个点
所以我们只需要暴力求出每一个点的坐标，再枚举你所走的点的起点与终点(只往一个方向走连续的点肯定是最优)
判断距离(从初始位置走到起点的距离再加上起点到终点的距离)是否小于t即可，求出一个最大值就是答案啊
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
ll x[],y[];
ll dis(ll x1,ll y1,ll x2,ll y2)
{
return abs(x1-x2)+abs(y1-y2);
}
int main()
{
ll ax,ay,bx,by,xs,ys,t;
int cnt=;
cin>>x[]>>y[]>>ax>>ay>>bx>>by;
cin>>xs>>ys>>t;
while(x[cnt]-xs<t&&y[cnt]-ys<t){
cnt++;
x[cnt]=x[cnt-]*ax+bx;
y[cnt]=y[cnt-]*ay+by;
}
int ans=;
for(int i=;i<=cnt;i++){
for(int j=i;j<=cnt;j++){
if(j-i+<=ans) continue;
ll temp=min(dis(x[i],y[i],xs,ys),dis(x[j],y[j],xs,ys));
temp+=dis(x[i],y[i],x[j],y[j]);
if(temp<=t) ans=j-i+;
}
}
cout<<ans<<endl;
return ;
}
1286 A.Garland(DP)
题意：
有一个数组，包含乱序1-n的元素，并且有些数被从数组中拿出，现在问怎样将这些数放回才能使，相邻两数为奇偶的对数最小
思路：
定义dp[i][j][k]为到n这个位置放了j个偶数最后一位为奇数或偶数
那么转移方程为：
令t=dp[i-1][j][k]
i.奇数：dp[i][j][1]=max(dp[i][j][1],t+(k!=1))
ii.偶数：dp[i][j+1][0]=max(dp[i][j][0],t+(k!=0))
#include<iostream>
#include<algorithm>
#include<cstring>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=;
int dp[maxn][maxn][],a[maxn],n;
int main()
{
int n,num=;
scanf("%d",&n);
for(int i=;i<=n;i++) scanf("%d",&a[i]);
num=n/;
memset(dp,inf,sizeof(dp));
dp[][][]=dp[][][]=;
for(int i=;i<=n;i++){
for(int j=;j<i;j++){
for(int k=;k<;k++){
int t=dp[i-][j][k];
if(a[i]){
if(a[i]%) dp[i][j][]=min(dp[i][j][],t+(k!=));
else dp[i][j+][]=min(dp[i][j+][],t+(k!=));
}
else{
for(int l=;l<;l++)
dp[i][j+-l][l]=min(dp[i][j+-l][l],t+(l!=k));
}
}
}
}
printf("%d\n", min(dp[n][num][], dp[n][num][]));
}
1285D Dr. Evil Underscores (01Trie+DFS)
题意：
给一个数组a，现在让你找到一个x使得max(x^ai)最小
思路：
建立起一颗Tire，对Tire进行DFS
如果对于当前位，即有0又有1，则对左右两个子树分别DFS并取最小值
当前位没有值的话，直接返回0
如果只有0或者1，那就对相应子树进行DFS
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=2e6+;
struct Tire{
int cnt,ch[maxn][];
void insert(int x)
{
int u=;
for(int i=;i>=;i--){
bool v=(<<i)&x;
if(!ch[u][v]){
ch[u][v]=++cnt;
}
u=ch[u][v];
}
}
int dfs(int x,int dep)
{
int k1=ch[x][],k2=ch[x][];
if(!k1&&!k2)
return ;
if(k1&&!k2)
return dfs(k1,dep-);
if(k2&&!k1)
return dfs(k2,dep-);
return (<<dep)+min(dfs(k1,dep-),dfs(k2,dep-));
} }T;
int main()
{
int n,temp;
scanf("%d",&n);
for(int i=;i<=n;i++){
scanf("%d",&temp);
T.insert(temp);
}
cout<<T.dfs(,)<<endl;
}
631C. Report(单调栈)
题意：
给你一个数组，并且进行若干次操作，每次操作可以将1-R，升序或者降序排列，求出经过若干次操作后的数组
思路：
对于一些操作，比如i < j并且Ri < Rj那么i操作是没有意义的，因此我们可以建立一个单调栈，将操作次数进行缩减，并得到一个以R降序的操作序列，最大的操作区间长度为len
现在将a数组的前len个元素复制到b数组，并且排序
之后从右向左向a数组中按照每次操作的排序方式填数即可
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=2e5+;
int a[maxn],b[maxn];
struct query{
int t,r;
}c[maxn];
int main()
{
int n,m,s=,t,r,l;
scanf("%d%d",&n,&m);
for(int i=;i<n;i++) scanf("%d",&a[i]);
for(int i=;i<=m;i++){
scanf("%d%d",&t,&r);
while(s>&&r>=c[s-].r) s--;
c[s].t=t,c[s].r=r,s++;
}
l=,r=c[].r,c[s].r=,s++;
for(int i=;i<r;i++) b[i]=a[i];
sort(b,b+r);
for(int i=;i<s;i++)
for(int j=c[i-].r;j>c[i].r;j--)
a[j-]=(c[i-].t==)?b[--r]:b[l++];
for(int i=;i<n;i++) cout<<a[i]<<" ";
return ;
}
1119D. Frets On Fire (二分+排序)
题意：
给n个数Ai，那么矩阵Ci,j = Ai + j(j≤1e18),现在给q个询问，每次询问这个矩阵l列到j列有多少个不同的元素
思路：
首先对a数组排序去重，显然这对答案不会有影响
对于排序去重之后数组中的两个相邻元素，如果他们之间的差值大于r-l+1，那么更小的那行对答案的贡献就为r-l+1，否则就为差值
因此我们求出一差分数组，并在此排序，求出前缀和sum数组
对于每次询问，我们用二分在差分数组中找到最后一个小于r-l+1的位置pos，那么本次查询的答案就为sun[pos] + (len-pos+1)*(r-l+1)
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e5+;
ll a[maxn],b[maxn],sum[maxn],l,r,ans[maxn];
int n,q;
int main()
{
scanf("%d",&n);
for(int i=;i<=n;i++) scanf("%lld",&a[i]);
sort(a+,a++n);
int len=unique(a+,a++n)-a-;
for(int i=;i<len;i++) b[i]=a[i+]-a[i];
sort(b+,b+len);
for(int i=;i<len;i++) sum[i]=sum[i-]+b[i];
scanf("%d",&q);
for(int i=;i<=q;i++){
scanf("%lld%lld",&l,&r);
int li=,ri=len-;
ll ret=r-l+;
while(li<=ri){
int mid=(li+ri)>>;
if(b[mid]<=r-l+) li=mid+;
else ri=mid-;
}
li--;
ret+=(sum[li]+(len-li-)*(r-l+));
cout<<ret<<" ";
}
}
1234D. Distinct Characters Queries(STL/线段树)
题意：
给一个字符串，两种操作:1.进行单点修改2.询问区间l-r有多少个不同的字母
思路：
方法一：建立26棵线段树
方法二：建立26个set，每个set存相应字母出现的位置
对于修改，先在原来的字母对应的set中删除位置，再在更新的字母对应的set中插入位置
由于set中元素都为有序的，所以每次询问，在每个set中进行二分找l如果找到的元素小于等于r答案就加一
#include<iostream>
#include<algorithm>
#include<set>
using namespace std;
set<int> a[];
string temp;
int main()
{
cin>>temp;
int n,op,pos,l,r;
char ch;
for(int i=;i<temp.size();i++) a[temp[i]-'a'].insert(i+);
scanf("%d",&n);
while(n--){
scanf("%d",&op);
if(op==){
cin>>pos>>ch;
a[temp[pos-]-'a'].erase(pos);
temp[pos-]=ch;
a[temp[pos-]-'a'].insert(pos);
}
else{
cin>>l>>r;
int num=;
for(int i=;i<;i++){
set<int>::iterator it;
it=a[i].lower_bound(l);
if(it!=a[i].end()&&*it<=r) num++;
}
cout<<num<<endl;
}
}
return ;
}
1073C. Vasya and Robot(二分+前缀和)
题意：
给你一串移动指令，与一个目的地，你可以对指令进行修改，每次修改的花费为，最右边的修改位置减去最左边的修改位置+1，让你求最少花费
思路：
二分答案进行判断，如何判断呢？
先用前缀和记录下每段指令中每个方向移动的次数
每次只需要判断x-(abs(ex-cntx)+abs(ey-cnty))是否为2的倍数即可，因为多出来的部分可以走相反的方向进行抵消，所以判断是否为2的倍数
其中cntx为为改变区域中在x方向上的移动距离，以x轴正方向为正，cnty类似
#include<iostream>
#include<algorithm>
#include<map>
#include<cmath>
using namespace std;
const int maxn=2e5+;
map<char,int> m;
int sum[][maxn],ex,ey,n;
string s;
int judge(int x)
{
int l,r,u,d,cntx,cnty;
if(x==n){
int temp=x-abs(ex)-abs(ey);
if(temp>=&&temp%==)
return ;
return ;
}
for(int i=;i<=n-x+;i++){
l=sum[][i-]+(sum[][n]-sum[][i+x-]);
r=sum[][i-]+(sum[][n]-sum[][i+x-]);
u=sum[][i-]+(sum[][n]-sum[][i+x-]);
d=sum[][i-]+(sum[][n]-sum[][i+x-]);
cnty=u-d,cntx=r-l;
int temp=x-(abs(ey-cnty)+abs(ex-cntx));
if(temp>=&&temp%==) return ;
}
return ;
}
int main()
{
scanf("%d",&n);
cin>>s>>ex>>ey;
int ret=-,l=,r=n;
m['L']=,m['R']=,m['U']=,m['D']=;
for(int i=;i<=n;i++){
for(int j=;j<;j++)
sum[j][i]=sum[j][i-];
sum[m[s[i-]]][i]++;
}
while(l<=r){
int mid=(l+r)>>;
if(judge(mid)) r=(ret=mid)-;
else l=mid+;
}
cout<<ret<<endl;
}
455A. Boredom(DP+map)
题意：
给一个数组，每次可以从数组中拿出一个数，但是每拿一次就得将所有x+1,x-1的数从数组中删除，问你能拿出数的最大和是多少
思路：
拿map记录下每个数出现的次数，然后对数组排序去重，之后开始DP
DP为选了第i个数的最大值
转移方程式为：dp[i]=max(dp[i],dp[i-1]+a[i]*s[a[i]]) (a[i]>a[i-1]+1)
dp[i]=max(dp[i],mx+a[i]*s[a[i]]) (mx为dp[1]-dp[i-2]中的最大值)
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
const int maxn=1e5+;
map<ll,int> s;
ll a[maxn],dp[maxn];
int main()
{
int n;
scanf("%d",&n);
for(int i=;i<=n;i++){
scanf("%lld",&a[i]);
s[a[i]]++;
}
sort(a+,a++n);
int len=unique(a+,a++n)-a-;
dp[]=a[]*s[a[]];
ll ans=dp[],mx=;
for(int i=;i<=len;i++){
if(a[i]>a[i-]+) dp[i]=max(dp[i],dp[i-]+a[i]*s[a[i]]);
dp[i]=max(dp[i],mx+a[i]*s[a[i]]);
mx=max(dp[i-],mx);
ans=max(ans,dp[i]);
}
cout<<ans<<endl;
return ;
}
225C. Barcode(DP)
题意：
有一个矩阵，每个位置是#或.，现你可以改变矩阵中某些位置，使得矩阵满足每列都相同，同一种符号的列连续出现的次数cnr必须满足,x≤cnt≤y
思路：
先求出把1-i列全部变成#的前缀和，然后定义dp[i][j]为前1-i列，最后连续一段为j所需要的最小花费
那么状态转移方程式为：f[i][0]=min(f[i][0],f[i-j][1]+(s[i]-s[i-j]))
f[i][1]=min(f[i][1],f[i-j][0]+n*j-(s[i]-s[i-j]))
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int a[][];
int s[];
char c[];
int f[][];
int main(){
memset(f,,sizeof(f));
f[][]=f[][]=;
int n,m,x,y;
scanf("%d%d%d%d",&n,&m,&x,&y);
for(int i=;i<=n;i++){
scanf("%s",c+);
for(int j=;j<=m;j++){
a[i][j]=(c[j]=='#'?:);
}
}
for(int i=;i<=m;i++){
for(int j=;j<=n;j++){
s[i]+=a[j][i];
}
s[i]+=s[i-];
}
for(int i=x;i<=m;i++){
for(int j=x;j<=y;j++){
if(i-j>=){
f[i][]=min(f[i][],f[i-j][]+(s[i]-s[i-j]));
f[i][]=min(f[i][],f[i-j][]+n*j-(s[i]-s[i-j]));
}
}
}
printf("%d\n", min(f[m][],f[m][]));
return ;
}
codeforces每日一题1-10的更多相关文章
- <每日一题>题目10：求斐波拉契数列
def func(x): m,n = 0,1 i = 0 while i < x: yield m m,n = n,m+n i += 1 fib = [] get_func = func(100 ...
- CISP/CISA 每日一题 10
CISA 每日一题(答)一个合理建造的数据仓库应当支持下列三种基本的查询格式: 1.向上溯源和向下溯源——向上溯源是对数据进行总计:向下溯源是将数据进行细化: 2.交叉溯源——通过通用属性访问数据仓库 ...
- 【Java每日一题】20161214
package Dec2016; import java.util.ArrayList; import java.util.List; public class Ques1214 { public s ...
- 【Java每日一题】20161212
package Dec2016; public class Ques1212 { public static void main(String[] args){ System.out.println( ...
- 【Java每日一题】20161020
20161019问题解析请点击今日问题下方的"[Java每日一题]20161020"查看 package Oct2016; public class Ques1020 { publ ...
- 【Java每日一题】20170112
20170111问题解析请点击今日问题下方的"[Java每日一题]20170112"查看(问题解析在公众号首发,公众号ID:weknow619) package Jan2017; ...
- 【Java每日一题】20170327
20170324问题解析请点击今日问题下方的“[Java每日一题]20170327”查看(问题解析在公众号首发,公众号ID:weknow619) package Mar2017; public cla ...
- 【Java每日一题】20170217
20170216问题解析请点击今日问题下方的“[Java每日一题]20170217”查看(问题解析在公众号首发,公众号ID:weknow619) package Feb2017; public cla ...
- 【Java每日一题】20170213
20170210问题解析请点击今日问题下方的“[Java每日一题]20170213”查看(问题解析在公众号首发,公众号ID:weknow619) package Feb2017; public cla ...
随机推荐
- multitask learning 相关论文资源
Multitask Learning / Domain Adaptation homepage: http://www.cs.cornell.edu/~kilian/research/multitas ...
- python的Django构建web应用
创建一个网上购物的网站 首先创建一个简单的python项目,然后在终端输入pip install django 安装Django框架 然后输入django-admin startproject pys ...
- Redis中RDB和AOF持久化区别和联系
RDB和AOF持久化 RDB持久化 RDB是什么? 原理是redis会单独创建(fork) 一个与当前进程一模一 样的子进程来进行持久化,这个子进程的所有数据(变量.环境变量,程序程序计数器等) ...
- linux 手工释放内存 高内存 内存回收 方法思路
linux 跑的apache,apache工作模式有 Prefork.Worker和 Event 三种,分别是基于进程.线程.综合模式. 本文中使用的apache是 Event ...
- 一键安装apache-2.4.38脚本
[root@lamp scripts]# cat /etc/redhat-release CentOS Linux release 7.5.1804 (Core) [root@lamp scripts ...
- SpringBoot基础篇-SpringBoot快速入门
SpringBoot基础 学习目标: 能够理解Spring的优缺点 能够理解SpringBoot的特点 能够理解SpringBoot的核心功能 能够搭建SpringBoot的环境 能够完成applic ...
- C语言结构体定义位域，从bit0开始，依次到最高bit位
位域是指信息在存储时,并不需要占用一个完整的字节, 而只需占几个或一个二进制位.例如在存放一个开关量时,只有0和1 两种状态, 用一位二进位即可.为了节省存储空间,并使处理简便,C语言又提供了一种数据 ...
- 解决IIS程序池回收webapi定时程序造成的影响
问题描述: webapi中有一个定时器线程,在iis程序池在1740分钟回收后,定时器中止 问题解决步骤: 1.设置程序池定期回收,设置每天定时回收 2.在windows自带的任务计划中,添加一条任务 ...
- 实战kudu集成impala
推荐阅读: 论主数据的重要性(正确理解元数据.数据元) CDC+ETL实现数据集成方案 Java实现impala操作kudu 实战kudu集成impala impala基本介绍 im ...
- ELK学习001：Elastic Stack简介
ELK简介: ELK Stack:ELK是Elasticsearch.Logstash.Kibana的缩写简称,这三者都是开源软件.ELK是5.0版本前的统称:这是一套统一的日志收集分析系统.它能够方 ...