private void Events_MapZoomEnded(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
if (IsEnabled)
{
_ZoomLevelTextBox.Text = GetZoomLevel();
}
}
public ZoomSliderControl(BIT.AVL.Silver.Map.Map map)
{
_Map = map;
DefaultStyleKey = typeof(ZoomSliderControl);
if(HtmlPage.IsEnabled)
{
_Thumb = new Thumb();
_Slider = this;
// Slider Events
_Slider.GotFocus += Slider_GotFocus;
_Slider.LostFocus += Slider_LostFocus;
_Slider.ValueChanged += ZoomControl_ValueChanged;
// Map Events
_Map.Events.MapMouseEnter += Events_MapMouseEnter;
_Map.Events.MapMouseLeave += Events_MapMouseLeave;
_Map.Events.MapZoomStarted += Events_MapZoomStarted;
_Map.Events.MapZoomEnded += Events_MapZoomEnded;
_Map.Events.MapZoomChanged += Events_MapZoomChanged;
_Map.Events.MapMouseWheel += Events_MapMouseWheel;
_Map.Events.MapDoubleClick += Events_MapDoubleClick;
_Map.Events.MapTileSourceChanged += Events_MapTileSourceChanged;
SetTileSourceZoomLevels();
_UpdateSlider = true;
}
}
static int[] Solve(int n, long[] a)
{
var res = new int[n];
BIT <long> bit = new BIT <long>(n + 1, 0, (x, y) => x + y);
for (int i = 0; i < bit.Size; i++)
{
bit.Operate(i, i);
}
for (int i = a.Length - 1; i >= 1; i--)
{
int valid = n + 1;
int invalid = -1;
while (valid - invalid > 1)
{
var mid = (valid + invalid) / 2;
if (a[i] < bit.Query(mid))
{
valid = mid;
}
else
{
invalid = mid;
}
}
res[i] = valid;
bit.Operate(res[i], -res[i]);
}
res[0] = (int)bit.Query(bit.Size - 1);
return(res);
}
static void Main()
{
Console.SetOut(new System.IO.StreamWriter(Console.OpenStandardOutput())
{
AutoFlush = false
});
var h = Read();
var n = h[0];
var a = Read();
var st = new BIT(n);
for (int i = 0; i < n; i++)
{
st.Add(i + 1, a[i]);
}
for (int k = 0; k < h[1]; k++)
{
var q = Read();
if (q[0] == 0)
{
st.Add(q[1] + 1, q[2]);
}
else
{
Console.WriteLine(st.Sum(q[1] + 1, q[2] + 1));
}
}
Console.Out.Flush();
}
private void Events_MapZoomChanged(BIT.AVL.Silver.Map.Map map, double zoomLevel)
{
if (IsEnabled)
{
_ZoomLevelTextBox.Text = GetZoomLevel();
}
}
public static void Main()
{
var n = NextInt;
var k = NextInt;
var reducedA = new int[n];
for (int i = 0; i < n; i++)
{
reducedA[i] = NextInt - k;
}
var accum = new long[n + 1];
for (int i = 0; i < reducedA.Length; i++)
{
accum[i + 1] = accum[i] + reducedA[i];
}
//var compressDict = accum.Distinct().OrderBy(x => x).Select((elem, ind) => new Tuple { Item1 = elem, Item2 = ind }).ToDictionary(x => x.Item1, x => x.Item2);
var distincted = accum.Distinct().ToArray();
Array.Sort(distincted);
long res = 0;
BIT <int> bit = new BIT <int>(distincted.Length, 0, (x, y) => x + y);
for (int i = 0; i < accum.Length; i++)
{
var ind = Array.BinarySearch(distincted, accum[i]);
res += bit.Query(ind);
bit.Operate(ind, 1);
}
Console.WriteLine(res);
}
public int ReversePairs(int[] nums)
{
SortedSet <long> allNumbers = new SortedSet <long>();
foreach (int num in nums)
{
allNumbers.Add((long)num);
allNumbers.Add(2 * (long)num);
}
Dictionary <long, int> values = new Dictionary <long, int>();
int index = 0;
foreach (var num in allNumbers)
{
values.Add(num, index);
index++;
}
int res = 0;
BIT bit = new BIT(values.Count);
for (int i = 0; i < nums.Length; i++)
{
int left = values[(long)nums[i] * 2];
int right = values.Count - 1;
res += bit.Query(right + 1) - bit.Query(left + 1);
bit.Update(values[(long)nums[i]] + 1, 1);
}
return(res);
}
// i 以下のインデックスのうち、交換回数が k 以下となる最小値
static int[] GetLeft(int n, long k, int[] a)
{
var left = new int[n];
var bit = new BIT(n);
var inv = 0L;
var ui = new bool[n];
var uj = new bool[n];
var q = TwoPointers(n, n, (i, j) =>
{
if (!uj[j] && j > 0)
{
inv -= bit.Sum(1, a[j - 1]);
bit.Add(a[j - 1], -1);
}
if (!ui[i])
{
inv += bit.Sum(a[i] + 1, n + 1);
bit.Add(a[i], 1);
}
ui[i] = uj[j] = true;
return(inv <= k);
});
foreach (var(i, j) in q)
{
left[i] = j;
}
return(left);
}
static object Solve()
{
var n = int.Parse(Console.ReadLine());
var a = Read();
var map = new CompressionHashMap(a);
var m = map.Count;
var dpu = new BIT(m);
var dpd = new BIT(m);
foreach (var v in a)
{
var i = map[v] + 1;
dpu.Add(i, dpd.Sum(i - 1));
dpd.Add(i, dpu.Sum(i + 1, m + 1));
dpu.Add(i, 1);
dpd.Add(i, 1);
dpu[i] %= M;
dpd[i] %= M;
}
return((dpu.Sum(m) + dpd.Sum(m) - 2 * n + M) % M);
}
static void Main()
{
var(n, qc) = Read2();
var qs = Array.ConvertAll(new bool[qc], _ => Read());
var bit = new BIT(n);
Console.SetOut(new System.IO.StreamWriter(Console.OpenStandardOutput())
{
AutoFlush = false
});
foreach (var q in qs)
{
var k = q[1];
if (q[0] == 1)
{
var v = bit.Sum(k <= n ? n - k + 1 : k - n, n + 1);
Console.WriteLine(v % 2 == 0 ? k : 2 * n - k + 1);
}
else
{
bit.Add(k, 1);
}
}
Console.Out.Flush();
}
void Build(int n)
{
Array.Sort(pos, (a, b) => (a.X == b.X ? a.Y - b.Y : a.X - b.X));
int[] a = new int[n];
HashSet <int> set = new HashSet <int>();
for (int i = 0; i < n; i++)
{
a[i] = pos[i].Y - pos[i].X;
set.Add(pos[i].Y - pos[i].X);
}
int num = set.Count;
int[] b = new int[num];
int index = 0;
foreach (int element in set)
{
b[index++] = element;
}
Array.Sort(b);
BIT bit = new BIT(num + 1);
for (int i = n - 1; i >= 0; i--)
{
int poss = BinarySearch(b, a[i]) + 1;
int j = bit.query(poss);
if (j != -1)
{
int dis = Math.Abs(pos[i].X - pos[j].X) + Math.Abs(pos[i].Y - pos[j].Y);
edges.Add((dis, pos[i].Id, pos[j].Id));
static object Solve()
{
var n = int.Parse(Console.ReadLine());
var a = Read();
var p2 = MPows(2, n);
var p2_ = MPows(MHalf, n);
var map = new CompressionHashMap(a);
var bit = new BIT(map.Count);
var r = 0L;
for (int i = 0; i < n; i++)
{
var v = map[a[i]] + 1;
r += bit.Sum(v) % M * p2_[n - i];
r %= M;
bit.Add(v, p2[n - 1 - i]);
}
return(r);
}
private void Events_MapViewChanged(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
if (IsEnabled)
{
_xCoordTextBox.Text = GetXCoordinate();
_yCoordTextBox.Text = GetYCoordinate();
}
}
public void solve()
{
int n = sc.Int;
var p = new int[n];
var l = new int[n];
var r = new int[n];
var idx = new int[n];
for (int i = 0; i < n; i++)
{
idx[i] = i;
sc.Multi(out p[i], out l[i], out r[i]);
}
var cmp = compress(p, l, r);
p = p.Select(x => cmp[x]).ToArray();
l = l.Select(x => cmp[x]).ToArray();
r = r.Select(x => cmp[x]).ToArray();
Array.Sort(idx, (i, j) => p[i].CompareTo(p[j]));
var ql = new PriorityQueue <int>((i, j) => l[j].CompareTo(l[i]));
var qr = new PriorityQueue <int>((i, j) => r[j].CompareTo(r[i]));
for (int i = 0; i < n; i++)
{
ql.Push(i);
}
var bit = new BIT(cmp.Count);
long ans = 0;
foreach (var i in idx)
{
while (ql.Count > 0 && l[ql.Top] <= p[i])
{
int x = ql.Pop();
bit.add(p[x], 1);
qr.Push(x);
}
while (qr.Count > 0 && r[qr.Top] < p[i])
{
int x = qr.Pop();
bit.add(p[x], -1);
}
ans += bit.sum(l[i], r[i] + 1);
}
for (int i = 0; i < n; i++)
{
if (l[i] <= p[i] && p[i] <= r[i])
{
--ans;
}
}
Assert(ans % 2 == 0);
Prt(ans / 2);
} // end Solver.solve
private void Events_MapMouseEnter(BIT.AVL.Silver.Map.Map map, MouseEventArgs args)
{
VisualStateManager.GoToState(this, "MouseOver", true);
if (IsEnabled)
{
_xCoordTextBox.Text = GetXCoordinate();
_yCoordTextBox.Text = GetYCoordinate();
}
}
private void Events_MapMouseMove(BIT.AVL.Silver.Map.Map map, MouseEventArgs args)
{
_LastMouseLocation = args.GetPosition(map);
if (IsEnabled)
{
_xCoordTextBox.Text = GetXCoordinate();
_yCoordTextBox.Text = GetYCoordinate();
}
}
static bool ReadBiometric()
{
//Give some time in order to Load the whole configuration
System.Threading.Thread.Sleep(1000);
BiometricFacade biometricFacade = reader.GetBiometricFacade();
try
{
biometricFacade.ReadBiometricInfoTemplates();
BIT firstBit = biometricFacade.FirstBit;
BIT secondBit = biometricFacade.SecondBit;
int refDataQualifier = firstBit.ReferenceDataQualifier;
Console.WriteLine("Please place your \"{0}\" over the biometric sensor:", GetFingerIndexType(firstBit.FingerIndex).Name);
try
{
SensorDevice sensor = new SagemSensorDevice();
// SensorDevice sensor = new DermalogSensorDevice
FingerIndexType fingerIndex = FingerIndexType.LEFT_INDEX_TYPE;
FTP_Image image = sensor.CaptureImage(firstBit.FingerIndex);
BiometricFacade bio = reader.GetBiometricFacade();
FTP_Template template = bio.ConvertImage(image, FormatType.ISO_19794_CS.Format);
if (image == null || image.Pixels == null)
{
return(false);
}
bool result = biometricFacade.MatchOnCard(firstBit, template);
//bool result = biometricFacade.MatchOffCard(firstBit, template);
//int result = biometricFacade.ReadFingerprints();
Console.WriteLine("Is Valid? {0}", result);
}
catch (MiddlewareException ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Sensor Error: {0}", ex.Message);
Console.ResetColor();
}
}
catch (MiddlewareException ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Biometric error: {0}", ex.Message);
Console.ResetColor();
}
return(false);
}
void bitWrite(ref byte value, byte bit, BIT b)
{
if (b == BIT.SET)
{
bitSet(ref value, bit);
}
else
{
bitClear(ref value, bit);
}
}
public void Solve()
{
var h = new HashSet <long>();
h.Add(0);
for (int i = 0; i < N; i++)
{
h.Add(A[i]);
}
var l = h.ToList();
l.Sort();
var dic = new Dictionary <long, int>();
for (int i = 0; i < l.Count; i++)
{
dic.Add(l[i], i);
}
long max = 0;
List <int> pos = new List <int>();
for (int i = 0; i < N; i++)
{
if (max < A[i])
{
pos.Add(i);
max = A[i];
}
}
var cntBT = new BIT(N);
var totBT = new BIT(N);
for (int i = 0; i < N; i++)
{
cntBT.Add(dic[A[i]] + 1, 1);
totBT.Add(dic[A[i]] + 1, A[i]);
}
long total = A.Sum();
long done = 0;
long[] ans = new long[N];
for (int i = pos.Count - 1; i > 0; i--)
{
long del = (total - totBT.Sum(dic[A[pos[i - 1]]])) - A[pos[i - 1]] * (N - cntBT.Sum(dic[A[pos[i - 1]]]));
ans[pos[i]] = del - done;
done = del;
}
ans[0] = total - done;
Console.WriteLine(String.Join("\n", ans));
}
public TileSource(BIT.AVL.Silver.Map.Map mapInstance)
: base(
(int)Math.Pow(2, DefaultMaxZoomLevel) * DefaultTileSize,
(int)Math.Pow(2, DefaultMaxZoomLevel) * DefaultTileSize,
DefaultTileSize,
DefaultTileSize,
0)
{
map = mapInstance;
}
public void Solve()
{
for (int i = 0; i < N; i++)
{
A[i] -= K;
}
long[] sum = new long[N + 1];
for (int i = 0; i < N; i++)
{
sum[i + 1] = sum[i] + A[i];
}
long Inf = (long)1e18;
HashSet <long> H = new HashSet <long>();
H.Add(-Inf);
H.Add(Inf);
H.Add(0);
foreach (var v in sum)
{
H.Add(v);
}
var L = H.ToList();
L.Sort();
var dic = new Dictionary <long, int>();
for (int i = 0; i < L.Count; i++)
{
dic.Add(L[i], i);
}
int NN = N * 2;
var BT = new BIT(NN);
for (int i = 1; i <= N; i++)
{
BT.Add(dic[sum[i]] + 1, 1);
}
long ans = 0;
ans += N - BT.Sum(dic[L[dic[0]]]);
BT.Add(dic[sum[1]] + 1, -1);
BT.Add(dic[-Inf] + 1, 1);
for (int i = 1; i < N; i++)
{
ans += N - BT.Sum(dic[L[dic[sum[i]]]]);
BT.Add(dic[sum[i + 1]] + 1, -1);
BT.Add(dic[-Inf] + 1, 1);
}
Console.WriteLine(ans);
}
static void Main(string [] args)
{
int [] a = { 3, 6, 1, 7, 2, 8, 4, 9, 10 };
var bit = new BIT(a.Length);
bit.Build(a);
bit.Print();
Console.WriteLine(bit.Sum(a.Length - 1));
bit.Update(3, 2);
Console.WriteLine(bit.Sum(1, 3));
}
public static long Inversion(int[] s)
{
var ans = 0L;
var bit = new BIT(s.Length);
for (var j = 0; j < s.Length; j++)
{
ans += j - bit.Sum(s[j]);
bit.Add(s[j], 1);
}
return(ans);
}
public static long InversionNumber(int n, int[] a)
{
var r = 0L;
var bit = new BIT(n);
for (int i = 0; i < n; ++i)
{
r += i - bit.Sum(a[i]);
bit.Add(a[i], 1);
}
return(r);
}
static long Solve()
{
var S = ReadLine();
var s = S.Select(c => c - 'a').ToArray();
int N = S.Length, odd = 0, mid = -1;
var cnt = new int[26];
foreach (var c in s)
{
cnt[c]++;
}
for (var c = 0; c < 26; c++)
{
if (cnt[c] % 2 == 1)
{
mid = c; odd++;
}
cnt[c] /= 2;
}
if (odd > 1)
{
return(-1);
}
var left = new List <int>();
foreach (var c in s)
{
if (cnt[c] > 0)
{
cnt[c]--; left.Add(c);
}
}
int[] t = new int[N], ind = new int[26], p = new int[N];
for (var i = 0; i < left.Count; i++)
{
t[N - 1 - i] = t[i] = left[i];
}
if (mid >= 0)
{
t[N / 2] = mid;
}
for (var i = 0; i < N; i++)
{
var c = s[i];
while (t[ind[c]] != c)
{
ind[c]++;
}
p[i] = ind[c]++;
}
return(BIT.Inversion(p));
}
/// <summary>
/// MouseControl Constructor, will use the default instance of the map
/// </summary>
/// <param name="map">Instance of Map</param>
public MouseControl(BIT.AVL.Silver.Map.Map map)
{
_Map = map;
DefaultStyleKey = typeof(MouseControl);
// Test IsDesignTime, to help display control in blend correctly
if(HtmlPage.IsEnabled)
{
HtmlPage.Document.AttachEvent("DOMMouseScroll", OnMouseWheelFirefox);
HtmlPage.Document.AttachEvent("onmousewheel", OnMouseWheelOther);
IsWheelEnabled = true;
}
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
var a = Console.ReadLine().Split().Select(int.Parse).Select((x, i) => new { x, i }).OrderBy(_ => _.x).ToArray();
var st = new BIT(n);
var r = 0L;
for (int i = 0; i < n; i++)
{
r += st.Sum(a[i].i + 1, n + 1);
st.Add(a[i].i + 1, 1);
}
Console.WriteLine(r);
}
/// <summary>
/// A Raster Tile Layer for the map
/// </summary>
/// <param name="map">Instance of the map in which to create the layer</param>
public TileLayer(BIT.AVL.Silver.Map.Map map)
{
_Map = map;
_Msi = new MultiScaleImage();
Children.Add(_Msi);
_Msi.Loaded += _Msi_Loaded;
_Msi.LayoutUpdated += (o, e) => CheckViewBounds();
_Msi.MotionFinished += (o, e) => _Map.Events.ZoomEnded(_Map, new MapEventArgs());
_LastViewWidth = _Msi.ViewportWidth;
_Msi.ViewportChanged += _Msi_ViewportChanged;
Overlays = new ObservableCollection<ITileSource>();
//This null TileSource allows the MSI to size itself correctly and earlier
_Msi.Source = new TileSource(map);
}
public static void Main()
{
var n = NextInt;
BIT <int> bit = new BIT <int>(100001, 0, Max);
foreach (var boxes in Enumerable.Repeat(0, n).Select(_ => new Box()
{
X = NextInt, Y = NextInt
}).GroupBy(x => x.X).OrderBy(x => x.Key))
{
foreach (var item in boxes.Select(x => new { Pos = x.Y, Res = bit.Query(x.Y) }).ToArray())
{
bit.Operate(item.Pos, item.Res + 1);
}
}
var res = bit.Query(bit.Size);
Console.WriteLine(res);
}
static void Main()
{
Console.WriteLine("I love you");
int [] arr = { 4, 6, 1, 8, 3, 2, 9, 0, 5, 7 };
var bit = new BIT(arr);
bit.Display();
Console.WriteLine();
for (int i = 0; i < arr.Length; i++)
{
Console.Write(bit.Sum(i) + " ");
}
bit.Update(10, 7);
Console.WriteLine();
for (int i = 0; i < arr.Length; i++)
{
Console.Write(bit.Sum(i) + " ");
}
Console.Write(bit.Sum(1) - bit.Sum(0));
}
static void Main()
{
int n = NextInt;
var q = NextInt;
BIT <int> bit = new BIT <int>(n + 1, 0, (x, y) => x + y);
StringBuilder builder = new StringBuilder();
for (int i = 0; i < q; i++)
{
if (NextInt == 0)
{
bit.Operate(NextInt, NextInt);
}
else
{
builder.AppendLine((-bit.Query(NextInt - 1) + bit.Query(NextInt)).ToString());
}
}
Console.Write(builder.ToString());
}
static object Solve()
{
var(n, k) = ((int, long))Read2L();
var a = Read();
var compMap = new CompressionHashMap(a);
a = compMap.Compressed;
a = Array.ConvertAll(a, x => x + 1);
var left = GetLeft(n, k, a);
var bit = new BIT(n + 1);
bit[1] = 1;
for (int i = 0; i < n; i++)
{
bit[i + 2] = bit.Sum(left[i] + 1, i + 2) % M;
}
return(bit[n + 1]);
}
static void Main()
{
var k = int.Parse(Console.ReadLine());
var a = new int[k].Select(_ => { Console.ReadLine(); return(Read()); }).ToArray();
Console.ReadLine();
var b = Read();
var t = a.Select(ai => Tally(ai, 20)).ToArray();
var inv = a.Select(ai =>
{
var sum = 0L;
var bit = new BIT(20);
foreach (var x in ai)
{
sum += bit.Sum(x + 1, 21);
bit.Add(x, 1);
}
return(sum);
}).ToArray();
var st = new BIT(20);
var r = 0L;
foreach (var bi in b)
{
for (int x = 1; x <= 20; x++)
{
r = (r + st.Sum(x + 1, 21) * t[bi - 1][x]) % M;
}
r = (r + inv[bi - 1]) % M;
for (int x = 1; x <= 20; x++)
{
st.Add(x, t[bi - 1][x]);
}
}
Console.WriteLine(r);
}
public static void Main()
{
int n = int.Parse(Console.ReadLine());
var a = Console.ReadLine().Split().Select(int.Parse).ToArray();
var compress = a.Distinct().OrderByDescending(x => x).Select((Elem, Count) => new { Elem, Count }).ToDictionary(x => x.Elem, x => x.Count);
long res = 0;
for (int i = 0; i < n; i++)
{
//一点加算/区間和が可能なBinary Indexed Tree(BIT)
BIT <int> bit = new BIT <int>(compress.Count, 0, (x, y) => x + y);
for (int k = i + 1; k < n; k++)
{
//max(a_i, a_k)より大きい要素の数の和(座標圧縮先のindexに直してからquery)
res += bit.Query(compress[Max(a[i], a[k])]);
//今の点についてBITに追加
bit.Operate(compress[a[k]], 1);
}
}
Console.WriteLine(res);
}
static void Main()
{
BIT <int> bit = new BIT <int>(NextInt + 1, 0, (x, y) => x + y);
int q = NextInt;
StringBuilder builder = new StringBuilder();
for (int i = 0; i < q; i++)
{
if (NextInt == 0)
{
var l = NextInt;
var r = NextInt;
var x = NextInt;
bit.Operate(l, x);
bit.Operate(r + 1, -x);
}
else
{
builder.AppendLine(bit.Query(NextInt).ToString());
}
}
Console.Write(builder.ToString());
}
static void Validate(int n)
{
Random rng = new Random();
var res = Enumerable.Range(1, n).OrderBy(x => rng.Next()).ToArray();
BIT <long> bit = new BIT <long>(n + 1, 0, (x, y) => x + y);
long[] a = new long[n];
for (int i = 0; i < res.Length; i++)
{
a[i] = bit.Query(res[i]);
bit.Operate(res[i], res[i]);
}
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
var ans = Solve(n, a);
Console.WriteLine(watch.ElapsedMilliseconds);
if (res.Zip(ans, (x, y) => x != y).Any(x => x))
{
Console.WriteLine(string.Join(" ", res));
Console.WriteLine(string.Join(" ", Solve(n, a)));
Console.WriteLine(string.Join(" ", a));
}
}
void Events_MapViewChanged(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
_ScaleTextBox.Text = GetMapScale(map);
}
private void Events_MapMouseEnter(BIT.AVL.Silver.Map.Map map, MouseEventArgs args)
{
VisualStateManager.GoToState(this, "MouseOver", true);
}
private void Events_MapMouseLeave(BIT.AVL.Silver.Map.Map map, MouseEventArgs args)
{
VisualStateManager.GoToState(this, "Normal", true);
}
//****************************************************************************
//メソッド名：OutBit（指定ポートにビット単位での出力）
//引数：引数�@ ポート名（"P00"、"P01"・・・"P07"）引数�A出力値（H：0/ L: 1）
//戻り値：正常０、異常１
//****************************************************************************
public int OutBit(PORT pName, BIT bName, OUT data)
{
//ポートの特定
byte PortOutData = 0;
switch (pName)
{
case PORT.P0:
this.Port = EPX64R_PORT0;
PortOutData = this.p0Outdata;
break;
case PORT.P1:
this.Port = EPX64R_PORT1;
PortOutData = this.p1Outdata;
break;
case PORT.P2:
this.Port = EPX64R_PORT2;
PortOutData = this.p2Outdata;
break;
case PORT.P3:
this.Port = EPX64R_PORT3;
PortOutData = this.p3Outdata;
break;
case PORT.P4:
this.Port = EPX64R_PORT4;
PortOutData = this.p4Outdata;
break;
case PORT.P5:
this.Port = EPX64R_PORT5;
PortOutData = this.p5Outdata;
break;
case PORT.P6:
this.Port = EPX64R_PORT6;
PortOutData = this.p6Outdata;
break;
case PORT.P7:
this.Port = EPX64R_PORT7;
PortOutData = this.p7Outdata;
break;
default:
return(1);
}
//ビットの特定
byte Temp = 0;
int Num = 0;
switch (bName)
{
case BIT.b0:
Num = 0; Temp = 0xFE;
break;
case BIT.b1:
Num = 1; Temp = 0xFD;
break;
case BIT.b2:
Num = 2; Temp = 0xFB;
break;
case BIT.b3:
Num = 3; Temp = 0xF7;
break;
case BIT.b4:
Num = 4; Temp = 0xEF;
break;
case BIT.b5:
Num = 5; Temp = 0xDF;
break;
case BIT.b6:
Num = 6; Temp = 0xBF;
break;
case BIT.b7:
Num = 7; Temp = 0x7F;
break;
}
//データの出力
byte Data = 0;
switch (data)
{
case OUT.H:
Data = 1;
break;
case OUT.L:
Data = 0;
break;
}
byte OutputValue = (byte)((PortOutData & Temp) | (Data << Num));//byteでｷｬｽﾄしないと怒られる
int flag = EPX64R.EPX64R_OutputPort(this.hDevice, Port, OutputValue);
if (flag != EPX64R.EPX64R_OK)
{
EPX64R.EPX64R_Close(this.hDevice); // Device Close
//MessageBox.Show("EPX64R_OutputPort() Error");
return(1);
}
switch (pName)
{
case PORT.P0:
this.p0Outdata = OutputValue;
break;
case PORT.P1:
this.p1Outdata = OutputValue;
break;
case PORT.P2:
this.p2Outdata = OutputValue;
break;
case PORT.P3:
this.p3Outdata = OutputValue;
break;
case PORT.P4:
this.p4Outdata = OutputValue;
break;
case PORT.P5:
this.p5Outdata = OutputValue;
break;
case PORT.P6:
this.p6Outdata = OutputValue;
break;
case PORT.P7:
this.p7Outdata = OutputValue;
break;
}
return(0);
}
/// <summary>
/// MapEvents constructor, will use the specific instance of the map
/// </summary>
public MapEvents(BIT.AVL.Silver.Map.Map map)
{
_Map = map;
}
public void Solve()
{
int N = S.Length;
int M = T.Length;
var BTSA = new BIT(N);
var BTSB = new BIT(N);
var BTTA = new BIT(N);
var BTTB = new BIT(N);
for (int i = 0; i < N; i++)
{
if (S[i] == 'A')
{
BTSA.Add(i + 1, 1);
}
if (S[i] == 'B')
{
BTSB.Add(i + 1, 1);
}
}
for (int i = 0; i < M; i++)
{
if (T[i] == 'A')
{
BTTA.Add(i + 1, 1);
}
if (T[i] == 'B')
{
BTTB.Add(i + 1, 1);
}
}
int[][] jud = new int[3][];
jud[0] = new int[] { 0, -1, 1 };
jud[1] = new int[] { 1, 0, -1 };
jud[2] = new int[] { -1, 1, 0 };
var sbd = new StringBuilder();
for (int q = 0; q < Q; q++)
{
int a = Query[q][0];
int b = Query[q][1];
int c = Query[q][2];
int d = Query[q][3];
int sa = BTSA.Sum(b) - BTSA.Sum(a - 1);
int sb = BTSB.Sum(b) - BTSB.Sum(a - 1);
int ta = BTTA.Sum(d) - BTTA.Sum(c - 1);
int tb = BTTB.Sum(d) - BTTB.Sum(c - 1);
sa %= 3;
sb %= 3;
ta %= 3;
tb %= 3;
if (jud[sa][sb] == jud[ta][tb])
{
sbd.AppendLine("YES");
}
else
{
sbd.AppendLine("NO");
}
}
Console.Write(sbd.ToString());
}
private void RaiseIfMouseDrag(BIT.AVL.Silver.Map.Map map, MouseEventArgs args)
{
if(EnableMouseClicks && _IsMouseDown)
{
if(_LastClick != 0)
{
//If we are not zooming, go to drag right away, otherwise delay to not conflict with a double click zoom.
if(_InZoom == false || (DateTime.Now.Ticks - _LastClick) > MouseDragDelay) // (TimeSpan.FromSeconds(0.15).TotalMilliseconds * 10000)
{
if(MapMouseDrag != null) MapMouseDrag(map, args);
}
}
}
}
internal void RotationChanged(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
if(MapRotationChanged != null) MapRotationChanged(map, args);
}
private void Events_MapMouseLeave(BIT.AVL.Silver.Map.Map map, MouseEventArgs args)
{
VisualStateManager.GoToState(this, "Normal", true);
_xCoordTextBox.Text = GetXCoordinate();
_yCoordTextBox.Text = GetYCoordinate();
}
internal void ZoomStarted(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
_InZoom = true;
if(MapZoomStarted != null) MapZoomStarted(map, args);
}
internal void ViewChanged(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
//Note this operation exists to eliminate the high volume of insignificant updates from MSI.ViewUpdated
//Uses the sum of squares to determine distance moved.
//The MSI woble effect seeems to occur at ~ a .03% of the logical display.
//So seeting the change tolerance at .05 eliminates much of the woble effect especially post zoom.
double distLogChange = Math.Sqrt(Math.Pow(_Map.LogicalOrigin.X - _PriorOrigin.X, 2) + Math.Pow(_Map.LogicalOrigin.Y - _PriorOrigin.Y, 2));
double changeSignificance = 100 * distLogChange / _Map.MapViewLogicalSize.Width;
if(changeSignificance > ChangeSignificanceThreshold)
{
_PriorOrigin = _Map.LogicalOrigin;
RaiseZoomChanged(map, map.ZoomLevel);
if(MapViewChanged != null) MapViewChanged(map, args);
}
}
internal void ZoomEnded(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
_InZoom = false;
if(MapZoomEnded != null) MapZoomEnded(map, args);
}
internal void TileSourceChanged(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
if(MapTileSourceChanged != null) MapTileSourceChanged(map, args);
}
public CoordControl(BIT.AVL.Silver.Map.Map map)
{
_Map = map;
DefaultStyleKey = typeof (CoordControl);
}
private void Events_MapZoomChanged(BIT.AVL.Silver.Map.Map map, double zoomLevel)
{
_ScaleTextBox.Text = GetMapScale(map);
}
private void RaiseZoomChanged(BIT.AVL.Silver.Map.Map map, double zoom)
{
if(_LastZoom != zoom)
{
_LastZoom = zoom;
ZoomChanged temp = MapZoomChanged;
if(temp != null)
{
MapZoomChanged(map, zoom);
}
}
}
static void Main()
{
var s = sc.Str;
int n = s.Length;
var ind = new List <int> [26];
for (int i = 0; i < 26; i++)
{
ind[i] = new List <int>();
}
var bit = new BIT(n);
for (int i = 0; i < n; i++)
{
ind[s[i] - 'a'].Add(i);
bit.add(i, 1);
}
int oc = 0;
var l = new int[26];
var r = new int[26];
for (int i = 0; i < 26; i++)
{
r[i] = ind[i].Count - 1;
if (ind[i].Count % 2 == 1)
{
++oc;
}
}
if (oc > 1)
{
DBG(-1);
return;
}
long sum = 0;
while (true)
{
int min = M, minid = -1;
for (int i = 0; i < 26; i++)
{
if (l[i] >= r[i])
{
continue;
}
int cos = (int)(bit.sum(ind[i][l[i]]) + bit.sum(ind[i][r[i]] + 1, n));
if (cos < min)
{
min = cos;
minid = i;
}
}
if (min == M)
{
break;
}
sum += min;
bit.add(ind[minid][l[minid]], -1);
bit.add(ind[minid][r[minid]], -1);
++l[minid];
--r[minid];
}
Prt(sum);
sw.Flush();
}
private void Events_MapZoomEnded(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
_ScaleTextBox.Text = GetMapScale(map);
}
internal void MouseWheel(BIT.AVL.Silver.Map.Map map, MouseWheelEventArgs args)
{
if(EnableMouseWheel)
{
if(MapMouseWheel != null) MapMouseWheel(map, args);
}
}
private static string GetMapScale(BIT.AVL.Silver.Map.Map map)
{
return "1:" + Math.Round(map.Scale, 0);
}
internal void MouseLeave(BIT.AVL.Silver.Map.Map map, MouseEventArgs args)
{
if(MapMouseLeave != null) MapMouseLeave(map, args);
}
/// <summary>
/// ScaleControl Constructor, will use the specific instance of the map
/// </summary>
/// <param name="map">Instance of Map</param>
public ScaleControl(BIT.AVL.Silver.Map.Map map)
{
_Map = map;
DefaultStyleKey = typeof(ScaleControl);
}
internal void Loaded(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
if(MapLoaded != null) MapLoaded(map, args);
}
internal void DragBehavourChanged(BIT.AVL.Silver.Map.Map map, MapEventArgs args)
{
if(MapDragBehavourChanged != null) MapDragBehavourChanged(map, args);
}
