目录:

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并且R< 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的更多相关文章

  1. <每日一题>题目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 ...

  2. CISP/CISA 每日一题 10

    CISA 每日一题(答)一个合理建造的数据仓库应当支持下列三种基本的查询格式: 1.向上溯源和向下溯源——向上溯源是对数据进行总计:向下溯源是将数据进行细化: 2.交叉溯源——通过通用属性访问数据仓库 ...

  3. 【Java每日一题】20161214

    package Dec2016; import java.util.ArrayList; import java.util.List; public class Ques1214 { public s ...

  4. 【Java每日一题】20161212

    package Dec2016; public class Ques1212 { public static void main(String[] args){ System.out.println( ...

  5. 【Java每日一题】20161020

    20161019问题解析请点击今日问题下方的"[Java每日一题]20161020"查看 package Oct2016; public class Ques1020 { publ ...

  6. 【Java每日一题】20170112

    20170111问题解析请点击今日问题下方的"[Java每日一题]20170112"查看(问题解析在公众号首发,公众号ID:weknow619) package Jan2017; ...

  7. 【Java每日一题】20170327

    20170324问题解析请点击今日问题下方的“[Java每日一题]20170327”查看(问题解析在公众号首发,公众号ID:weknow619) package Mar2017; public cla ...

  8. 【Java每日一题】20170217

    20170216问题解析请点击今日问题下方的“[Java每日一题]20170217”查看(问题解析在公众号首发,公众号ID:weknow619) package Feb2017; public cla ...

  9. 【Java每日一题】20170213

    20170210问题解析请点击今日问题下方的“[Java每日一题]20170213”查看(问题解析在公众号首发,公众号ID:weknow619) package Feb2017; public cla ...

随机推荐

  1. MySQL的简介

    什么是数据库 1. 数据库(Database)是按照数据结构来组织.存储和管理数据的仓库,每个数据库都有一个或多个不同 的API(接口)用于创建,访问,管理,搜索和复制所保存的数据 2. 我们也可以将 ...

  2. Yandex Big Data Essentials Week1 Unix Command Line Interface File System exploration

    File System Function In computing, a file system or filesystem is used to control how data is stored ...

  3. Dockerfile的使用

    一 什么是Dockerfile Dockerfile是由一系列命令和参数构成的脚本,这些命令应用于基础镜像并最终创建一个新的镜像. 1.对于开发人员:可以为开发团队提供一个完全一致的开发环境: 2.对 ...

  4. Java逃逸分析

    Java逃逸分析 记录下看到的别人的博客内容,以后深入了解再详细写篇,加深下基础概念和印象! 一般来说,Java对象的创建,通常是在堆空间中分配内存,但是如果大量的临时对象也在堆空间创建的话,会导致性 ...

  5. Prometheus监控k8s集合

    Prometheus监控k8s Prometheus监控k8s(1)-Prometheus简介 Prometheus监控k8s(2)-手动部署Prometheus Prometheus监控k8s(3) ...

  6. 为什么Linux 实例执行 df 和 du 查看磁盘时结果不一致

    问题现象 执行 df -h 查看 ECS Linux 实例文件系统使用率,可以看到 /dev/xvdb1 磁盘占用了约27G,挂载目录为 /opt . 进入到 /opt 目录执行 du -sh ,显示 ...

  7. js类的constructor中不支持异步函数吗?

    解决方案: 1.如果是普通函数,可以用async 和await来解决你的问题但你这个是在constructor里,constructor 的作用是返回一个对像实例,如果加了async就变成返回一个pr ...

  8. BFC的语法

    先说一下什么是BFC(Block Formatting Contexts) BFC:块级格式化上下文(独立的渲染区).通俗的说是块级元素布局逻辑或规则,想要触发BFC就要是块级元素,要不把它转为块级元 ...

  9. Android中点击按钮获取string.xml中内容并弹窗提示

    场景 AndroidStudio跑起来第一个App时新手遇到的那些坑: https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/103797 ...

  10. Python和Anoconda和Pycharm安装教程

    简介 Python是一种跨平台的计算机程序设计语言.是一种面向对象的动态类型语言,最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越多被用于独立的.大型项目的开发. ...